| | 1 | (function (root, factory) { |
| | 2 | if (typeof exports === 'object') { |
| | 3 | // For nodejs |
| | 4 | var SunCalc = require('suncalc'); |
| | 5 | module.exports = factory(SunCalc); |
| | 6 | } else { |
| | 7 | // For browsers |
| | 8 | root.opening_hours = factory(root.SunCalc); |
| | 9 | } |
| | 10 | }(this, function (SunCalc) { |
| | 11 | var SunCalc; |
| | 12 | return function(value, nominatiomJSON) { |
| | 13 | //====================================================================== |
| | 14 | // Constants |
| | 15 | //====================================================================== |
| | 16 | var holidays = { |
| | 17 | 'de': { |
| | 18 | 'PH': { // http://de.wikipedia.org/wiki/Feiertage_in_Deutschland |
| | 19 | 'Neujahrstag' : [ 1, 1 ], // month 1, day 1, whole Germany |
| | 20 | 'Heilige Drei Könige' : [ 1, 6, [ 'Baden-Württemberg', 'Bayern', 'Sachsen-Anhalt'] ], // only in the specified states |
| | 21 | 'Tag der Arbeit' : [ 5, 1 ], // whole Germany |
| | 22 | 'Karfreitag' : [ 'easter', -2 ], // two days before easter |
| | 23 | 'Ostersonntag' : [ 'easter', 0, [ 'Brandenburg'] ], |
| | 24 | 'Ostermontag' : [ 'easter', 1 ], |
| | 25 | 'Christi Himmelfahrt' : [ 'easter', 39 ], |
| | 26 | 'Pfingstsonntag' : [ 'easter', 49, [ 'Brandenburg'] ], |
| | 27 | 'Pfingstmontag' : [ 'easter', 50 ], |
| | 28 | 'Fronleichnam' : [ 'easter', 60, [ 'Baden-Württemberg', 'Bayern', 'Hessen', 'Nordrhein-Westfalen', 'Rheinland-Pfalz', 'Saarland' ] ], |
| | 29 | 'Mariä Himmelfahrt' : [ 8, 15, [ 'Saarland'] ], |
| | 30 | 'Tag der Deutschen Einheit' : [ 10, 3 ], |
| | 31 | 'Reformationstag' : [ 10, 31, [ 'Brandenburg', 'Mecklenburg-Vorpommern', 'Sachsen', 'Sachsen-Anhalt', 'Thüringen'] ], |
| | 32 | 'Allerheiligen' : [ 11, 1, [ 'Baden-Württemberg', 'Bayern', 'Nordrhein-Westfalen', 'Rheinland-Pfalz', 'Saarland' ] ], |
| | 33 | '1. Weihnachtstag' : [ 12, 25 ], |
| | 34 | '2. Weihnachtstag' : [ 12, 26 ], |
| | 35 | // 'Silvester' : [ 12, 31 ], // for testing |
| | 36 | }, |
| | 37 | 'Baden-Württemberg': { // does only apply in Baden-Württemberg |
| | 38 | // This more specific rule set overwrites the country wide one (they are just ignored). |
| | 39 | // You may use this instead of the country wide with some |
| | 40 | // additional holidays for some states, if one state |
| | 41 | // totally disagrees about how to do public holidays … |
| | 42 | // 'PH': { |
| | 43 | // '2. Weihnachtstag' : [ 12, 26 ], |
| | 44 | // }, |
| | 45 | |
| | 46 | // school holiday normally variate between states |
| | 47 | 'SH': [ // generated by convert_ical_to_json |
| | 48 | // You may can adjust this script to use other resources (for other countries) too. |
| | 49 | { |
| | 50 | name: 'Osterferien', |
| | 51 | 2005: [ 3, 24, /* to */ 3, 24, 3, 29, /* to */ 4, 2 ], |
| | 52 | 2006: [ 4, 18, /* to */ 4, 22 ], |
| | 53 | 2007: [ 4, 2, /* to */ 4, 14 ], |
| | 54 | 2008: [ 3, 17, /* to */ 3, 28 ], |
| | 55 | 2009: [ 4, 9, /* to */ 4, 9, 4, 14, /* to */ 4, 17 ], |
| | 56 | 2010: [ 4, 1, /* to */ 4, 1, 4, 6, /* to */ 4, 10 ], |
| | 57 | 2011: [ 4, 21, /* to */ 4, 21, 4, 26, /* to */ 4, 30 ], |
| | 58 | 2012: [ 4, 2, /* to */ 4, 13 ], |
| | 59 | 2013: [ 3, 25, /* to */ 4, 5 ], |
| | 60 | 2014: [ 4, 14, /* to */ 4, 25 ], |
| | 61 | 2015: [ 3, 30, /* to */ 4, 10 ], |
| | 62 | 2016: [ 3, 29, /* to */ 4, 2 ], |
| | 63 | 2017: [ 4, 10, /* to */ 4, 21 ], |
| | 64 | }, |
| | 65 | { |
| | 66 | name: 'Pfingstferien', |
| | 67 | 2005: [ 5, 17, /* to */ 5, 28 ], |
| | 68 | 2006: [ 5, 29, /* to */ 6, 10 ], |
| | 69 | 2007: [ 5, 29, /* to */ 6, 9 ], |
| | 70 | 2008: [ 5, 13, /* to */ 5, 23 ], |
| | 71 | 2009: [ 5, 25, /* to */ 6, 6 ], |
| | 72 | 2010: [ 5, 25, /* to */ 6, 5 ], |
| | 73 | 2011: [ 6, 14, /* to */ 6, 25 ], |
| | 74 | 2012: [ 5, 29, /* to */ 6, 9 ], |
| | 75 | 2013: [ 5, 21, /* to */ 6, 1 ], |
| | 76 | 2014: [ 6, 10, /* to */ 6, 21 ], |
| | 77 | 2015: [ 5, 26, /* to */ 6, 6 ], |
| | 78 | 2016: [ 5, 17, /* to */ 5, 28 ], |
| | 79 | 2017: [ 6, 6, /* to */ 6, 16 ], |
| | 80 | }, |
| | 81 | { |
| | 82 | name: 'Sommerferien', |
| | 83 | 2005: [ 7, 28, /* to */ 9, 10 ], |
| | 84 | 2006: [ 8, 3, /* to */ 9, 16 ], |
| | 85 | 2007: [ 7, 26, /* to */ 9, 8 ], |
| | 86 | 2008: [ 7, 24, /* to */ 9, 6 ], |
| | 87 | 2009: [ 7, 30, /* to */ 9, 12 ], |
| | 88 | 2010: [ 7, 29, /* to */ 9, 11 ], |
| | 89 | 2011: [ 7, 28, /* to */ 9, 10 ], |
| | 90 | 2012: [ 7, 26, /* to */ 9, 8 ], |
| | 91 | 2013: [ 7, 25, /* to */ 9, 7 ], |
| | 92 | 2014: [ 7, 31, /* to */ 9, 13 ], |
| | 93 | 2015: [ 7, 30, /* to */ 9, 12 ], |
| | 94 | 2016: [ 7, 28, /* to */ 9, 10 ], |
| | 95 | 2017: [ 7, 27, /* to */ 9, 9 ], |
| | 96 | }, |
| | 97 | { |
| | 98 | name: 'Herbstferien', |
| | 99 | 2005: [ 11, 2, /* to */ 11, 4 ], |
| | 100 | 2006: [ 10, 30, /* to */ 11, 3 ], |
| | 101 | 2007: [ 10, 29, /* to */ 11, 3 ], |
| | 102 | 2008: [ 10, 27, /* to */ 10, 31 ], |
| | 103 | 2009: [ 10, 26, /* to */ 10, 31 ], |
| | 104 | 2010: [ 11, 2, /* to */ 11, 6 ], |
| | 105 | 2011: [ 10, 31, /* to */ 10, 31, 11, 2, /* to */ 11, 4 ], |
| | 106 | 2012: [ 10, 29, /* to */ 11, 2 ], |
| | 107 | 2013: [ 10, 28, /* to */ 10, 30 ], |
| | 108 | 2014: [ 10, 27, /* to */ 10, 30 ], |
| | 109 | 2015: [ 11, 2, /* to */ 11, 6 ], |
| | 110 | 2016: [ 11, 2, /* to */ 11, 4 ], |
| | 111 | }, |
| | 112 | { |
| | 113 | name: 'Weihnachtsferien', |
| | 114 | 2005: [ 12, 22, /* to */ 1, 5 ], |
| | 115 | 2006: [ 12, 27, /* to */ 1, 5 ], |
| | 116 | 2007: [ 12, 24, /* to */ 1, 5 ], |
| | 117 | 2008: [ 12, 22, /* to */ 1, 10 ], |
| | 118 | 2009: [ 12, 23, /* to */ 1, 9 ], |
| | 119 | 2010: [ 12, 23, /* to */ 1, 8 ], |
| | 120 | 2011: [ 12, 23, /* to */ 1, 5 ], |
| | 121 | 2012: [ 12, 24, /* to */ 1, 5 ], |
| | 122 | 2013: [ 12, 23, /* to */ 1, 4 ], |
| | 123 | 2014: [ 12, 22, /* to */ 1, 5 ], |
| | 124 | 2015: [ 12, 23, /* to */ 1, 9 ], |
| | 125 | 2016: [ 12, 23, /* to */ 1, 7 ], |
| | 126 | }, |
| | 127 | ], |
| | 128 | }, |
| | 129 | 'Bremen': { |
| | 130 | 'SH': [ |
| | 131 | { |
| | 132 | name: 'Winterferien', |
| | 133 | 2012: [ 1, 30, /* to */ 1, 31 ], |
| | 134 | 2013: [ 1, 31, /* to */ 2, 1 ], |
| | 135 | 2014: [ 1, 30, /* to */ 1, 31 ], |
| | 136 | 2015: [ 2, 2, /* to */ 2, 3 ], |
| | 137 | }, |
| | 138 | { |
| | 139 | name: 'Osterferien', |
| | 140 | 2012: [ 3, 26, /* to */ 4, 11, 4, 30, /* to */ 4, 30 ], |
| | 141 | 2013: [ 3, 16, /* to */ 4, 2 ], |
| | 142 | 2014: [ 4, 3, /* to */ 4, 22, 5, 2, /* to */ 5, 2 ], |
| | 143 | 2015: [ 3, 25, /* to */ 4, 10 ], |
| | 144 | }, |
| | 145 | { |
| | 146 | name: 'Pfingstferien', |
| | 147 | 2012: [ 5, 18, /* to */ 5, 18, 5, 29, /* to */ 5, 29 ], |
| | 148 | 2013: [ 5, 10, /* to */ 5, 10, 5, 21, /* to */ 5, 21 ], |
| | 149 | 2014: [ 5, 30, /* to */ 5, 30, 6, 10, /* to */ 6, 10 ], |
| | 150 | 2015: [ 5, 15, /* to */ 5, 15, 5, 26, /* to */ 5, 26 ], |
| | 151 | }, |
| | 152 | { |
| | 153 | name: 'Sommerferien', |
| | 154 | 2012: [ 7, 23, /* to */ 8, 31 ], |
| | 155 | 2013: [ 6, 27, /* to */ 8, 7 ], |
| | 156 | 2014: [ 7, 31, /* to */ 9, 10 ], |
| | 157 | 2015: [ 7, 23, /* to */ 9, 2 ], |
| | 158 | }, |
| | 159 | { |
| | 160 | name: 'Herbstferien', |
| | 161 | 2012: [ 10, 22, /* to */ 11, 3 ], |
| | 162 | 2013: [ 10, 4, /* to */ 10, 18 ], |
| | 163 | 2014: [ 10, 27, /* to */ 11, 8 ], |
| | 164 | 2015: [ 10, 19, /* to */ 10, 31 ], |
| | 165 | }, |
| | 166 | { |
| | 167 | name: 'Weihnachtsferien', |
| | 168 | 2012: [ 12, 24, /* to */ 1, 5 ], |
| | 169 | 2013: [ 12, 23, /* to */ 1, 4], |
| | 170 | 2014: [ 12, 22, /* to */ 1, 5 ], |
| | 171 | 2015: [ 12, 23, /* to */ 12, 31 ], |
| | 172 | }, |
| | 173 | ], |
| | 174 | }, |
| | 175 | }, |
| | 176 | 'at': { |
| | 177 | 'PH': { // http://de.wikipedia.org/wiki/Feiertage_in_%C3%96sterreich |
| | 178 | 'Neujahrstag' : [ 1, 1 ], |
| | 179 | 'Heilige Drei Könige' : [ 1, 6 ], |
| | 180 | // 'Josef' : [ 3, 19, [ 'Kärnten', 'Steiermark', 'Tirol', 'Vorarlberg' ] ], |
| | 181 | // 'Karfreitag' : [ 'easter', -2 ], |
| | 182 | 'Ostermontag' : [ 'easter', 1 ], |
| | 183 | 'Staatsfeiertag' : [ 5, 1 ], |
| | 184 | // 'Florian' : [ 5, 4, [ 'Oberösterreich' ] ], |
| | 185 | 'Christi Himmelfahrt' : [ 'easter', 39 ], |
| | 186 | 'Pfingstmontag' : [ 'easter', 50 ], |
| | 187 | 'Fronleichnam' : [ 'easter', 60 ], |
| | 188 | 'Mariä Himmelfahrt' : [ 8, 15 ], |
| | 189 | // 'Rupert' : [ 9, 24, [ 'Salzburg' ] ], |
| | 190 | // 'Tag der Volksabstimmung' : [ 10, 10, [ 'Kärnten' ] ], |
| | 191 | 'Nationalfeiertag' : [ 10, 26 ], |
| | 192 | 'Allerheiligen' : [ 11, 1 ], |
| | 193 | // 'Martin' : [ 11, 11, [ 'Burgenland' ] ], |
| | 194 | // 'Leopold' : [ 11, 15, [ 'Niederösterreich', 'Wien' ] ], |
| | 195 | 'Mariä Empfängnis' : [ 12, 8 ], |
| | 196 | // 'Heiliger Abend' : [ 12, 24 ], |
| | 197 | 'Christtag' : [ 12, 25 ], |
| | 198 | 'Stefanitag' : [ 12, 26 ], |
| | 199 | // 'Silvester' : [ 12, 31 ], |
| | 200 | }, |
| | 201 | }, |
| | 202 | }; |
| | 203 | |
| | 204 | //---------------------------------------------------------------------------- |
| | 205 | // error correction |
| | 206 | // Taken form http://www.netzwolf.info/j/osm/time_domain.js |
| | 207 | // Credits go to Netzwolf |
| | 208 | // |
| | 209 | // Key to word_error_correction is the token name except wrong_words |
| | 210 | //---------------------------------------------------------------------------- |
| | 211 | var word_error_correction = { |
| | 212 | wrong_words: { |
| | 213 | 'Assuming "<ok>" for "<ko>"': { |
| | 214 | summer: 'May-Oct', |
| | 215 | winter: 'Nov-Apr', |
| | 216 | }, 'Bitte benutze die englische Schreibweise "<ok>" für "<ko>".': { |
| | 217 | sommer: 'summer', |
| | 218 | }, 'Assuming "<ok>" for "<ko>". Please avoid using "workday": http://wiki.openstreetmap.org/wiki/Talk:Key:opening_hours#need_syntax_for_holidays_and_workingdays': { |
| | 219 | // // Used around 260 times but the problem is, that work day might be different in other countries. |
| | 220 | wd: 'Mo-Fr', |
| | 221 | weekday: 'Mo-Fr', |
| | 222 | weekdays: 'Mo-Fr', |
| | 223 | }, 'Please ommit "<ko>".': { |
| | 224 | h: '', |
| | 225 | }, 'Please ommit "<ko>". You might want to express open end which can be specified as "12:00+" for example': { |
| | 226 | from: '', |
| | 227 | }, 'Please use notation "<ok>" for "<ko>".': { |
| | 228 | '–': '-', |
| | 229 | to: '-', |
| | 230 | till: '-', |
| | 231 | and: ',', |
| | 232 | '&': ',', |
| | 233 | daily: 'Mo-Su', |
| | 234 | always: '24/7', |
| | 235 | midnight: '00:00', |
| | 236 | }, 'Please use time format in 24 hours notation ("<ko>").': { |
| | 237 | pm: '', |
| | 238 | am: '', |
| | 239 | }, 'Bitte verzichte auf "<ko>".': { |
| | 240 | uhr: '', |
| | 241 | }, 'Bitte verzichte auf "<ko>". Sie möchten eventuell eine Öffnungszeit ohne vorgegebenes Ende angeben. Beispiel: "12:00+"': { |
| | 242 | ab: '', |
| | 243 | von: '', |
| | 244 | }, 'Bitte benutze die Schreibweise "<ok>" für "<ko>".': { |
| | 245 | bis: '-', |
| | 246 | und: ',', |
| | 247 | }, 'Bitte benutze die englische Abkürzung "<ok>" für "<ko>".': { |
| | 248 | feiertag: 'PH', |
| | 249 | feiertage: 'PH', |
| | 250 | feiertagen: 'PH' |
| | 251 | }, 'S\'il vous plaît utiliser "<ok>" pour "<ko>".': { |
| | 252 | 'fermé': 'off', |
| | 253 | 'et': ',', |
| | 254 | 'à': '-', |
| | 255 | }, 'Neem de engelse afkorting "<ok>" voor "<ko>" alstublieft.': { |
| | 256 | feestdag: 'PH', |
| | 257 | feestdagen: 'PH', |
| | 258 | } |
| | 259 | }, |
| | 260 | |
| | 261 | month: { |
| | 262 | 'default': { |
| | 263 | jan: 0, |
| | 264 | feb: 1, |
| | 265 | mar: 2, |
| | 266 | apr: 3, |
| | 267 | may: 4, |
| | 268 | jun: 5, |
| | 269 | jul: 6, |
| | 270 | aug: 7, |
| | 271 | sep: 8, |
| | 272 | oct: 9, |
| | 273 | nov: 10, |
| | 274 | dec: 11, |
| | 275 | }, 'Please use the englisch abbreviation "<ok>" for "<ko>".': { |
| | 276 | january: 0, |
| | 277 | february: 1, |
| | 278 | march: 2, |
| | 279 | april: 3, |
| | 280 | // may: 4, |
| | 281 | june: 5, |
| | 282 | july: 6, |
| | 283 | august: 7, |
| | 284 | september: 8, |
| | 285 | october: 9, |
| | 286 | november: 10, |
| | 287 | december: 11, |
| | 288 | }, 'Bitte benutze die englische Abkürzung "<ok>" für "<ko>".': { |
| | 289 | januar: 0, |
| | 290 | februar: 1, |
| | 291 | märz: 2, |
| | 292 | maerz: 2, |
| | 293 | mai: 4, |
| | 294 | juni: 5, |
| | 295 | juli: 6, |
| | 296 | okt: 9, |
| | 297 | oktober: 9, |
| | 298 | dez: 11, |
| | 299 | dezember: 11, |
| | 300 | }, 'S\'il vous plaît utiliser l\'abréviation "<ok>" pour "<ko>".': { |
| | 301 | janvier: 0, |
| | 302 | février: 1, |
| | 303 | fév: 1, |
| | 304 | mars: 2, |
| | 305 | avril: 3, |
| | 306 | avr: 3, |
| | 307 | mai: 4, |
| | 308 | juin: 5, |
| | 309 | juillet: 6, |
| | 310 | août: 7, |
| | 311 | aoû: 7, |
| | 312 | septembre: 8, |
| | 313 | octobre: 9, |
| | 314 | novembre: 10, |
| | 315 | décembre: 11, |
| | 316 | }, 'Neem de engelse afkorting "<ok>" voor "<ko>" alstublieft.': { |
| | 317 | januari: 0, |
| | 318 | februari: 1, |
| | 319 | maart: 2, |
| | 320 | mei: 4, |
| | 321 | augustus: 7, |
| | 322 | } |
| | 323 | }, |
| | 324 | |
| | 325 | weekday: { |
| | 326 | 'default': { |
| | 327 | su: 0, |
| | 328 | mo: 1, |
| | 329 | tu: 2, |
| | 330 | we: 3, |
| | 331 | th: 4, |
| | 332 | fr: 5, |
| | 333 | sa: 6, |
| | 334 | }, 'Please use the abbreviation "<ok>" for "<ko>".': { |
| | 335 | sun: 0, |
| | 336 | sunday: 0, |
| | 337 | sundays: 0, |
| | 338 | mon: 1, |
| | 339 | monday: 1, |
| | 340 | mondays: 1, |
| | 341 | tue: 2, |
| | 342 | tuesday: 2, |
| | 343 | tuesdays: 2, |
| | 344 | wed: 3, |
| | 345 | wednesday: 3, |
| | 346 | wednesdays: 3, |
| | 347 | thu: 4, |
| | 348 | thursday: 4, |
| | 349 | thursdays: 4, |
| | 350 | fri: 5, |
| | 351 | friday: 5, |
| | 352 | fridays: 5, |
| | 353 | sat: 6, |
| | 354 | saturday: 6, |
| | 355 | saturdays: 6, |
| | 356 | }, 'Bitte benutze die englische Abkürzung "<ok>" für "<ko>".': { |
| | 357 | so: 0, |
| | 358 | son: 0, |
| | 359 | sonntag: 0, |
| | 360 | montag: 1, |
| | 361 | di: 2, |
| | 362 | die: 2, |
| | 363 | dienstag: 2, |
| | 364 | mi: 3, |
| | 365 | mit: 3, |
| | 366 | mittwoch: 3, |
| | 367 | 'do': 4, |
| | 368 | don: 4, |
| | 369 | donnerstag: 4, |
| | 370 | fre: 5, |
| | 371 | freitag: 5, |
| | 372 | sam: 6, |
| | 373 | samstag: 6, |
| | 374 | }, 'S\'il vous plaît utiliser l\'abréviation "<ok>" pour "<ko>".': { |
| | 375 | dim: 0, |
| | 376 | dimanche: 0, |
| | 377 | lu: 1, |
| | 378 | lun: 1, |
| | 379 | lundi: 1, |
| | 380 | mardi: 2, |
| | 381 | mer: 3, |
| | 382 | mercredi: 3, |
| | 383 | je: 4, |
| | 384 | jeu: 4, |
| | 385 | jeudi: 4, |
| | 386 | ve: 5, |
| | 387 | ven: 5, |
| | 388 | vendredi: 5, |
| | 389 | samedi: 6, |
| | 390 | }, 'Neem de engelse afkorting "<ok>" voor "<ko>" alstublieft.': { |
| | 391 | zo: 0, |
| | 392 | zon: 0, |
| | 393 | zontag: 0, |
| | 394 | maandag: 1, |
| | 395 | din: 2, |
| | 396 | dinsdag: 2, |
| | 397 | wo: 3, |
| | 398 | woe: 3, |
| | 399 | woensdag: 3, |
| | 400 | donderdag: 4, |
| | 401 | vr: 5, |
| | 402 | vri: 5, |
| | 403 | vrijdag: 5, |
| | 404 | za: 6, |
| | 405 | zat: 6, |
| | 406 | zaterdag: 6, |
| | 407 | } |
| | 408 | }, |
| | 409 | |
| | 410 | timevar: { // Special time variables which actual value depends on the date and the position of the facility. |
| | 411 | 'default': { |
| | 412 | sunrise: 'sunrise', |
| | 413 | sunset: 'sunset', |
| | 414 | dawn: 'dawn', |
| | 415 | dusk: 'dusk', |
| | 416 | }, 'Please use notation "<ok>" for "<ko>".': { |
| | 417 | sundown: 'sunset', |
| | 418 | }, 'Bitte benutze die Schreibweise "<ok>" für "<ko>".': { |
| | 419 | 'morgendämmerung': 'dawn', |
| | 420 | 'abenddämmerung': 'dusk', |
| | 421 | sonnenaufgang: 'sunrise', |
| | 422 | sonnenuntergang: ',', |
| | 423 | }, |
| | 424 | }, |
| | 425 | |
| | 426 | 'event': { // variable events |
| | 427 | 'default': { |
| | 428 | easter: 'easter', |
| | 429 | }, 'Bitte benutze die Schreibweise "<ok>" für "<ko>".': { |
| | 430 | ostern: 'easter', |
| | 431 | }, |
| | 432 | }, |
| | 433 | }; |
| | 434 | var word_value_replacement = { // if the correct values can not be calculated |
| | 435 | dawn : 60 * 5 + 30, |
| | 436 | sunrise : 60 * 6, |
| | 437 | sunset : 60 * 18, |
| | 438 | dusk : 60 * 18 + 30, |
| | 439 | }; |
| | 440 | var months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec']; |
| | 441 | var default_prettify_conf = { |
| | 442 | 'leading_zero_hour': true, // enforce leading zero |
| | 443 | 'one_zero_if_hour_zero': false, // only one zero "0" if hour is zero "0" |
| | 444 | 'leave_off_closed': true, // leave keywords of and closed as is |
| | 445 | 'keyword_for_off_closed': 'off', // use given keyword instead of "off" or "closed" |
| | 446 | 'block_sep_string': ' ', // separate blocks by string |
| | 447 | 'print_semicolon': true, // print token which separates normal blocks |
| | 448 | }; |
| | 449 | |
| | 450 | var minutes_in_day = 60 * 24; |
| | 451 | var msec_in_day = 1000 * 60 * minutes_in_day; |
| | 452 | var msec_in_week = msec_in_day * 7; |
| | 453 | |
| | 454 | //====================================================================== |
| | 455 | // Constructor - entry to parsing code |
| | 456 | //====================================================================== |
| | 457 | // Terminology: |
| | 458 | // |
| | 459 | // Mo-Fr 10:00-11:00; Th 10:00-12:00 |
| | 460 | // \_____block_____/ \____block___/ |
| | 461 | // |
| | 462 | // The README refers to blocks as rules, which is more intuitive but less clear. |
| | 463 | // Because of that only the README uses the term rule in that context. |
| | 464 | // In all internal parts of this project, the term block is used. |
| | 465 | // |
| | 466 | // Mo-Fr Jan 10:00-11:00 |
| | 467 | // \__/ \_/ \_________/ |
| | 468 | // selectors (left to right: weekday, month, time) |
| | 469 | // |
| | 470 | // Logic: |
| | 471 | // - Tokenize |
| | 472 | // Foreach block: |
| | 473 | // - Run toplevel (block) parser |
| | 474 | // - Which calls subparser for specific selector types |
| | 475 | // - Which produce selector functions |
| | 476 | |
| | 477 | |
| | 478 | // Evaluate additional information which can be given. They are |
| | 479 | // required to reasonably calculate 'sunrise' and so on and to use the |
| | 480 | // correct holidays. |
| | 481 | var location_cc, location_state, lat, lon; |
| | 482 | if (typeof nominatiomJSON != 'undefined') { |
| | 483 | if (typeof nominatiomJSON.address != 'undefined' && |
| | 484 | typeof nominatiomJSON.address.state != 'undefined') { // country_code will be tested later … |
| | 485 | location_cc = nominatiomJSON.address.country_code; |
| | 486 | location_state = nominatiomJSON.address.state; |
| | 487 | } |
| | 488 | |
| | 489 | if (typeof nominatiomJSON.lon != 'undefined') { // lat will be tested later … |
| | 490 | lat = nominatiomJSON.lat; |
| | 491 | lon = nominatiomJSON.lon; |
| | 492 | } |
| | 493 | } |
| | 494 | |
| | 495 | if (value.match(/^(\s*;?\s*)+$/)) throw 'Value contains nothing meaningful which can be parsed'; |
| | 496 | |
| | 497 | var parsing_warnings = []; |
| | 498 | var has_token = {}; |
| | 499 | var tokens = tokenize(value); |
| | 500 | // console.log(JSON.stringify(tokens, null, '\t')); |
| | 501 | var prettified_value = ''; |
| | 502 | var week_stable = true; |
| | 503 | |
| | 504 | var blocks = []; |
| | 505 | |
| | 506 | for (var nblock = 0; nblock < tokens.length; nblock++) { |
| | 507 | if (tokens[nblock][0].length == 0) continue; |
| | 508 | // Block does contain nothing useful e.g. second block of '10:00-12:00;' (empty) which needs to be handled. |
| | 509 | |
| | 510 | var continue_at = 0; |
| | 511 | do { |
| | 512 | if (continue_at == tokens[nblock][0].length) break; |
| | 513 | // Block does contain nothing useful e.g. second block of '10:00-12:00,' (empty) which needs to be handled. |
| | 514 | |
| | 515 | var selectors = { |
| | 516 | // Time selectors |
| | 517 | time: [], |
| | 518 | |
| | 519 | // Temporary array of selectors from time wrapped to the next day |
| | 520 | wraptime: [], |
| | 521 | |
| | 522 | // Date selectors |
| | 523 | weekday: [], |
| | 524 | holiday: [], |
| | 525 | week: [], |
| | 526 | month: [], |
| | 527 | monthday: [], |
| | 528 | year: [], |
| | 529 | |
| | 530 | // Array with non-empty date selector types, with most optimal ordering |
| | 531 | date: [], |
| | 532 | |
| | 533 | fallback: tokens[nblock][1], |
| | 534 | additional: continue_at ? true : false, |
| | 535 | meaning: true, |
| | 536 | unknown: false, |
| | 537 | comment: undefined, |
| | 538 | }; |
| | 539 | |
| | 540 | continue_at = parseGroup(tokens[nblock][0], continue_at, selectors); |
| | 541 | if (typeof continue_at == 'object') |
| | 542 | continue_at = continue_at[0]; |
| | 543 | else |
| | 544 | continue_at = 0; |
| | 545 | |
| | 546 | if (selectors.year.length > 0) |
| | 547 | selectors.date.push(selectors.year); |
| | 548 | if (selectors.holiday.length > 0) |
| | 549 | selectors.date.push(selectors.holiday); |
| | 550 | if (selectors.month.length > 0) |
| | 551 | selectors.date.push(selectors.month); |
| | 552 | if (selectors.monthday.length > 0) |
| | 553 | selectors.date.push(selectors.monthday); |
| | 554 | if (selectors.week.length > 0) |
| | 555 | selectors.date.push(selectors.week); |
| | 556 | if (selectors.weekday.length > 0) |
| | 557 | selectors.date.push(selectors.weekday); |
| | 558 | |
| | 559 | blocks.push(selectors); |
| | 560 | |
| | 561 | // this handles selectors with time ranges wrapping over midnight (e.g. 10:00-02:00) |
| | 562 | // it generates wrappers for all selectors and creates a new block |
| | 563 | if (selectors.wraptime.length > 0) { |
| | 564 | var wrapselectors = { |
| | 565 | time: selectors.wraptime, |
| | 566 | date: [], |
| | 567 | |
| | 568 | meaning: selectors.meaning, |
| | 569 | unknown: selectors.unknown, |
| | 570 | comment: selectors.comment, |
| | 571 | |
| | 572 | wrapped: true, |
| | 573 | }; |
| | 574 | |
| | 575 | for (var dselg = 0; dselg < selectors.date.length; dselg++) { |
| | 576 | wrapselectors.date.push([]); |
| | 577 | for (var dsel = 0; dsel < selectors.date[dselg].length; dsel++) { |
| | 578 | wrapselectors.date[wrapselectors.date.length-1].push( |
| | 579 | generateDateShifter(selectors.date[dselg][dsel], -msec_in_day) |
| | 580 | ); |
| | 581 | } |
| | 582 | } |
| | 583 | |
| | 584 | blocks.push(wrapselectors); |
| | 585 | } |
| | 586 | } while (continue_at) |
| | 587 | } |
| | 588 | |
| | 589 | // Tokenization function: Splits string into parts. |
| | 590 | // output: array of arrays of pairs [content, type] |
| | 591 | function tokenize(value) { |
| | 592 | var all_tokens = new Array(); |
| | 593 | var curr_block_tokens = new Array(); |
| | 594 | |
| | 595 | var last_block_fallback_terminated = false; |
| | 596 | |
| | 597 | while (value != '') { |
| | 598 | var tmp; |
| | 599 | if (tmp = value.match(/^(?:week\b|open|unknown)/i)) { |
| | 600 | // reserved word |
| | 601 | curr_block_tokens.push([tmp[0].toLowerCase(), tmp[0].toLowerCase(), value.length ]); |
| | 602 | value = value.substr(tmp[0].length); |
| | 603 | } else if (tmp = value.match(/^24\/7/i)) { |
| | 604 | // reserved word |
| | 605 | has_token[tmp[0]] = true; |
| | 606 | curr_block_tokens.push([tmp[0], tmp[0], value.length ]); |
| | 607 | value = value.substr(tmp[0].length); |
| | 608 | } else if (tmp = value.match(/^(?:off|closed)/i)) { |
| | 609 | // reserved word |
| | 610 | curr_block_tokens.push([tmp[0].toLowerCase(), 'closed', value.length ]); |
| | 611 | value = value.substr(tmp[0].length); |
| | 612 | } else if (tmp = value.match(/^(?:PH|SH)/i)) { |
| | 613 | // special day name (holidays) |
| | 614 | curr_block_tokens.push([tmp[0].toUpperCase(), 'holiday', value.length ]); |
| | 615 | value = value.substr(2); |
| | 616 | } else if (tmp = value.match(/^days?/i)) { |
| | 617 | curr_block_tokens.push([tmp[0].toLowerCase(), 'calcday', value.length ]); |
| | 618 | value = value.substr(tmp[0].length); |
| | 619 | } else if (tmp = value.match(/^(:?&|–|[a-zA-Z]+\b)/i)) { |
| | 620 | // Handle all remaining words with error tolerance |
| | 621 | var correct_val = returnCorrectWordOrToken(tmp[0].toLowerCase(), value.length); |
| | 622 | if (typeof correct_val == 'object') { |
| | 623 | curr_block_tokens.push([ correct_val[0], correct_val[1], value.length ]); |
| | 624 | value = value.substr(tmp[0].length); |
| | 625 | } else if (typeof correct_val == 'string') { |
| | 626 | value = correct_val + value.substr(tmp[0].length); |
| | 627 | } else { |
| | 628 | // other single-character tokens |
| | 629 | curr_block_tokens.push([value[0].toLowerCase(), value[0].toLowerCase(), value.length - 1 ]); |
| | 630 | value = value.substr(1); |
| | 631 | } |
| | 632 | } else if (tmp = value.match(/^\d+/)) { |
| | 633 | // number |
| | 634 | if (tmp[0] > 1900) // assumed to be a year number |
| | 635 | curr_block_tokens.push([tmp[0], 'year', value.length ]); |
| | 636 | else |
| | 637 | curr_block_tokens.push([+tmp[0], 'number', value.length ]); |
| | 638 | value = value.substr(tmp[0].length); |
| | 639 | } else if (tmp = value.match(/^"([^"]*)"/)) { |
| | 640 | // comment |
| | 641 | curr_block_tokens.push([tmp[1], 'comment', value.length ]); |
| | 642 | value = value.substr(tmp[0].length); |
| | 643 | } else if (value.match(/^;/)) { |
| | 644 | // semicolon terminates block |
| | 645 | // next tokens belong to a new block |
| | 646 | all_tokens.push([ curr_block_tokens, last_block_fallback_terminated, value.length ]); |
| | 647 | value = value.substr(1); |
| | 648 | |
| | 649 | curr_block_tokens = []; |
| | 650 | last_block_fallback_terminated = false; |
| | 651 | } else if (value.match(/^\|\|/)) { |
| | 652 | // || terminates block |
| | 653 | // next tokens belong to a fallback block |
| | 654 | if (curr_block_tokens.length == 0) |
| | 655 | throw formatWarnErrorMessage(-1, value.length - 2, 'Rule before fallback rule does not contain anything useful'); |
| | 656 | |
| | 657 | all_tokens.push([ curr_block_tokens, last_block_fallback_terminated, value.length ]); |
| | 658 | value = value.substr(2); |
| | 659 | |
| | 660 | curr_block_tokens = []; |
| | 661 | last_block_fallback_terminated = true; |
| | 662 | } else if (value.match(/^\s/)) { |
| | 663 | value = value.substr(1); |
| | 664 | } else if (tmp = value.match(/^\s+/)) { |
| | 665 | // whitespace is ignored |
| | 666 | value = value.substr(tmp[0].length); |
| | 667 | } else if (value.match(/^[:.]/)) { |
| | 668 | // time separator |
| | 669 | if (value[0] == '.') |
| | 670 | parsing_warnings.push([ -1, value.length - 1, 'Please use ":" as hour/minute-separator' ]); |
| | 671 | curr_block_tokens.push([ ':', 'timesep', value.length ]); |
| | 672 | value = value.substr(1); |
| | 673 | } else { |
| | 674 | // other single-character tokens |
| | 675 | curr_block_tokens.push([value[0].toLowerCase(), value[0].toLowerCase(), value.length ]); |
| | 676 | value = value.substr(1); |
| | 677 | } |
| | 678 | } |
| | 679 | |
| | 680 | all_tokens.push([ curr_block_tokens, last_block_fallback_terminated ]); |
| | 681 | |
| | 682 | return all_tokens; |
| | 683 | } |
| | 684 | |
| | 685 | // error correction/tolerance |
| | 686 | function returnCorrectWordOrToken(word, value_length) { |
| | 687 | for (var token_name in word_error_correction) { |
| | 688 | for (var comment in word_error_correction[token_name]) { |
| | 689 | for (var old_val in word_error_correction[token_name][comment]) { |
| | 690 | if (old_val == word) { |
| | 691 | var val = word_error_correction[token_name][comment][old_val]; |
| | 692 | if (token_name == 'wrong_words') { |
| | 693 | parsing_warnings.push([ -1, value_length - old_val.length, |
| | 694 | comment.replace(/<ko>/, old_val).replace(/<ok>/, val) ]); |
| | 695 | return val; |
| | 696 | } else if (comment != 'default'){ |
| | 697 | var correct_abbr; |
| | 698 | for (correct_abbr in word_error_correction[token_name]['default']) { |
| | 699 | if (word_error_correction[token_name]['default'][correct_abbr] == val) |
| | 700 | break; |
| | 701 | } |
| | 702 | if (token_name != 'timevar') { // normally written in lower case |
| | 703 | correct_abbr = correct_abbr.charAt(0).toUpperCase() + correct_abbr.slice(1); |
| | 704 | } |
| | 705 | parsing_warnings.push([ -1, value_length - old_val.length, |
| | 706 | comment.replace(/<ko>/, old_val).replace(/<ok>/, correct_abbr) ]); |
| | 707 | } |
| | 708 | return [ val, token_name ]; |
| | 709 | } |
| | 710 | } |
| | 711 | } |
| | 712 | } |
| | 713 | } |
| | 714 | |
| | 715 | function getWarnings(it) { |
| | 716 | |
| | 717 | if (typeof it == 'object') { // getWarnings was called in a state without critical errors. We can do extended tests. |
| | 718 | |
| | 719 | // Check if 24/7 is used and it does not mean 24/7 because there are other rules. This can be avoided. |
| | 720 | var has_advanced = it.advance(); |
| | 721 | |
| | 722 | if (has_advanced === true && has_token['24/7']) // Probably because of: "24/7; 12:00-14:00 open", ". Needs extra testing. |
| | 723 | parsing_warnings.push([ -1, 0, 'You used 24/7 in a way that is probably not interpreted as "24 hours 7 days a week".' |
| | 724 | + ' For correctness you might want to use "open" or "closed"' |
| | 725 | + ' for this rule and then write your exceptions which should achieve the same goal and is more clear' |
| | 726 | + ' e.g. "open; Mo 12:00-14:00 off".']); |
| | 727 | } |
| | 728 | |
| | 729 | var warnings = []; |
| | 730 | for (var i = 0; i < parsing_warnings.length; i++) { |
| | 731 | warnings.push( formatWarnErrorMessage(parsing_warnings[i][0], parsing_warnings[i][1], parsing_warnings[i][2]) ); |
| | 732 | } |
| | 733 | return warnings; |
| | 734 | } |
| | 735 | |
| | 736 | // Function to check token array for specific pattern |
| | 737 | function matchTokens(tokens, at /*, matches... */) { |
| | 738 | if (at + arguments.length - 2 > tokens.length) |
| | 739 | return false; |
| | 740 | for (var i = 0; i < arguments.length - 2; i++) { |
| | 741 | if (tokens[at + i][1] !== arguments[i + 2]) |
| | 742 | return false; |
| | 743 | } |
| | 744 | |
| | 745 | return true; |
| | 746 | } |
| | 747 | |
| | 748 | function generateDateShifter(func, shift) { |
| | 749 | return function(date) { |
| | 750 | var res = func(new Date(date.getTime() + shift)); |
| | 751 | |
| | 752 | if (typeof res[1] === 'undefined') |
| | 753 | return res; |
| | 754 | return [ res[0], new Date(res[1].getTime() - shift) ]; |
| | 755 | } |
| | 756 | } |
| | 757 | |
| | 758 | //====================================================================== |
| | 759 | // Top-level parser |
| | 760 | //====================================================================== |
| | 761 | function parseGroup(tokens, at, selectors, conf) { |
| | 762 | var prettified_group_value = ''; |
| | 763 | |
| | 764 | // console.log(tokens); // useful for debugging of tokenize |
| | 765 | while (at < tokens.length) { |
| | 766 | var old_at = at; |
| | 767 | var last_subparser; |
| | 768 | // console.log('Parsing at position', at +':', tokens[at]); |
| | 769 | if (matchTokens(tokens, at, 'weekday')) { |
| | 770 | at = parseWeekdayRange(tokens, at, selectors); |
| | 771 | } else if (matchTokens(tokens, at, '24/7')) { |
| | 772 | // selectors.time.push(function(date) { return [true]; }); // Not needed. If there is now selector it automatically matches everything. |
| | 773 | at++; |
| | 774 | } else if (matchTokens(tokens, at, 'holiday')) { |
| | 775 | if (matchTokens(tokens, at+1, ',', 'weekday')) |
| | 776 | at = parseHoliday(tokens, at, selectors, true); |
| | 777 | else |
| | 778 | at = parseHoliday(tokens, at, selectors, false); |
| | 779 | week_stable = false; |
| | 780 | } else if (matchTokens(tokens, at, 'month', 'number') |
| | 781 | || matchTokens(tokens, at, 'year', 'month', 'number') |
| | 782 | || matchTokens(tokens, at, 'year', 'event') |
| | 783 | || matchTokens(tokens, at, 'event')) { |
| | 784 | at = parseMonthdayRange(tokens, at); |
| | 785 | week_stable = false; |
| | 786 | } else if (matchTokens(tokens, at, 'year')) { |
| | 787 | at = parseYearRange(tokens, at); |
| | 788 | week_stable = false; |
| | 789 | } else if (matchTokens(tokens, at, 'month')) { |
| | 790 | at = parseMonthRange(tokens, at); |
| | 791 | // week_stable = false; // decided based on actual values |
| | 792 | } else if (matchTokens(tokens, at, 'week')) { |
| | 793 | at = parseWeekRange(tokens, at + 1); |
| | 794 | week_stable = false; |
| | 795 | } else if (at != 0 && at != tokens.length - 1 && tokens[at][0] == ':') { |
| | 796 | // Ignore colon if they appear somewhere else than as time separator. |
| | 797 | // This provides compatibility with the syntax proposed by Netzwolf: |
| | 798 | // http://www.netzwolf.info/en/cartography/osm/time_domain/specification |
| | 799 | if (matchTokens(tokens, at-1, 'weekday') || matchTokens(tokens, at-1, 'holiday')) |
| | 800 | parsing_warnings.push([nblock, at, 'Please don’t use ":" after ' + tokens[at-1][1] + '.']); |
| | 801 | |
| | 802 | if (prettified_group_value[-1] != ' ') |
| | 803 | prettified_group_value = prettified_group_value.substring(0, prettified_group_value.length - 1) |
| | 804 | at++; |
| | 805 | } else if (matchTokens(tokens, at, 'number', 'timesep') |
| | 806 | || matchTokens(tokens, at, 'timevar') |
| | 807 | || matchTokens(tokens, at, '(', 'timevar')) { |
| | 808 | at = parseTimeRange(tokens, at, selectors); |
| | 809 | last_subparser = 'time'; |
| | 810 | } else if (matchTokens(tokens, at, 'closed')) { |
| | 811 | selectors.meaning = false; |
| | 812 | at++; |
| | 813 | if (matchTokens(tokens, at, ',')) // additional block |
| | 814 | at = [ at + 1 ]; |
| | 815 | } else if (matchTokens(tokens, at, 'open')) { |
| | 816 | selectors.meaning = true; |
| | 817 | at++; |
| | 818 | if (matchTokens(tokens, at, ',')) // additional block |
| | 819 | at = [ at + 1 ]; |
| | 820 | } else if (matchTokens(tokens, at, 'unknown')) { |
| | 821 | selectors.meaning = false; |
| | 822 | selectors.unknown = true; |
| | 823 | at++; |
| | 824 | if (matchTokens(tokens, at, ',')) // additional block |
| | 825 | at = [ at + 1 ]; |
| | 826 | } else if (matchTokens(tokens, at, 'comment')) { |
| | 827 | selectors.comment = tokens[at][0]; |
| | 828 | if (at > 0) { |
| | 829 | if (!matchTokens(tokens, at - 1, 'open') |
| | 830 | && !matchTokens(tokens, at - 1, 'closed')) { |
| | 831 | // Then it is unknown. Either with unknown explicitly |
| | 832 | // specified or just a comment behind. |
| | 833 | selectors.meaning = false; |
| | 834 | selectors.unknown = true; |
| | 835 | } |
| | 836 | } else { // block starts with comment |
| | 837 | selectors.time.push(function(date) { return [true]; }); |
| | 838 | selectors.meaning = false; |
| | 839 | selectors.unknown = true; |
| | 840 | } |
| | 841 | at++; |
| | 842 | if (matchTokens(tokens, at, ',')) // additional block |
| | 843 | at = [ at + 1 ]; |
| | 844 | } else { |
| | 845 | var warnings = getWarnings(); |
| | 846 | throw formatWarnErrorMessage(nblock, at, 'Unexpected token: "' + tokens[at][1] |
| | 847 | + '" This means that the syntax is not valid at that point.') + (warnings ? ' ' + warnings.join('; ') : ''); |
| | 848 | } |
| | 849 | |
| | 850 | if (typeof conf != 'undefined') |
| | 851 | prettified_group_value += prettifySelector(tokens, old_at, at, conf, last_subparser); |
| | 852 | |
| | 853 | if (typeof at == 'object') // additional block |
| | 854 | break; |
| | 855 | } |
| | 856 | |
| | 857 | prettified_value += prettified_group_value.replace(/\s+$/, ''); |
| | 858 | |
| | 859 | return at; |
| | 860 | } |
| | 861 | |
| | 862 | //====================================================================== |
| | 863 | // Time range parser (10:00-12:00,14:00-16:00) |
| | 864 | //====================================================================== |
| | 865 | function parseTimeRange(tokens, at, selectors) { |
| | 866 | for (; at < tokens.length; at++) { |
| | 867 | var has_time_var_calc = [], has_normal_time = []; // element 0: start time, 1: end time |
| | 868 | has_normal_time[0] = matchTokens(tokens, at, 'number', 'timesep', 'number'); |
| | 869 | has_time_var_calc[0] = matchTokens(tokens, at, '(', 'timevar'); |
| | 870 | if (has_normal_time[0] || matchTokens(tokens, at, 'timevar') || has_time_var_calc[0]) { |
| | 871 | // relying on the fact that always *one* of them is true |
| | 872 | |
| | 873 | if (has_normal_time[0]) |
| | 874 | var minutes_from = tokens[at+has_time_var_calc[0]][0] * 60 + tokens[at+has_time_var_calc[0]+2][0]; |
| | 875 | else |
| | 876 | var minutes_from = word_value_replacement[tokens[at+has_time_var_calc[0]][0]]; |
| | 877 | |
| | 878 | var timevar_add = [ 0, 0 ]; |
| | 879 | if (has_time_var_calc[0]) { |
| | 880 | timevar_add[0] = parseTimevarCalc(tokens, at); |
| | 881 | minutes_from += timevar_add[0]; |
| | 882 | } |
| | 883 | |
| | 884 | var has_open_end = false; |
| | 885 | if (!matchTokens(tokens, at+(has_normal_time[0] ? 3 : (has_time_var_calc[0] ? 7 : 1)), '-')) { |
| | 886 | if (matchTokens(tokens, at+(has_normal_time[0] ? 3 : (has_time_var_calc[0] ? 7 : 1)), '+')) { |
| | 887 | has_open_end = true; |
| | 888 | } else { |
| | 889 | throw formatWarnErrorMessage(nblock, at+(has_normal_time[0] ? 3 : (has_time_var_calc[0] ? 2 : 1)), |
| | 890 | 'hyphen (-) or open end (+) in time range ' |
| | 891 | + (has_time_var_calc[0] ? 'calculation ' : '') |
| | 892 | + 'expected'); |
| | 893 | } |
| | 894 | } |
| | 895 | |
| | 896 | var at_end_time = at+(has_normal_time[0] ? 3 : (has_time_var_calc[0] ? 7 : 1))+1; // after '-' |
| | 897 | if (has_open_end) { |
| | 898 | if (minutes_from >= 22 * 60) |
| | 899 | var minutes_to = minutes_from + 60 * 8; |
| | 900 | else if (minutes_from >= 17 * 60) |
| | 901 | var minutes_to = minutes_from + 60 * 10; |
| | 902 | else |
| | 903 | var minutes_to = minutes_in_day; |
| | 904 | } else { |
| | 905 | has_normal_time[1] = matchTokens(tokens, at_end_time, 'number', 'timesep', 'number'); |
| | 906 | has_time_var_calc[1] = matchTokens(tokens, at_end_time, '(', 'timevar'); |
| | 907 | if (!has_normal_time[1] && !matchTokens(tokens, at_end_time, 'timevar') && !has_time_var_calc[1]) |
| | 908 | throw formatWarnErrorMessage(nblock, at_end_time, 'time range does not continue as expected'); |
| | 909 | |
| | 910 | if (has_normal_time[1]) |
| | 911 | var minutes_to = tokens[at_end_time][0] * 60 + tokens[at_end_time+2][0] |
| | 912 | else |
| | 913 | var minutes_to = word_value_replacement[tokens[at_end_time+has_time_var_calc[1]][0]]; |
| | 914 | |
| | 915 | if (has_time_var_calc[1]) { |
| | 916 | timevar_add[1] = parseTimevarCalc(tokens, at_end_time); |
| | 917 | minutes_to += timevar_add[1]; |
| | 918 | } |
| | 919 | |
| | 920 | // this shortcut makes always-open range check faster |
| | 921 | // and is also useful in tests, as it doesn't produce |
| | 922 | // extra check points which may hide errors in other |
| | 923 | // selectors |
| | 924 | if (minutes_from == 0 && minutes_to == minutes_in_day) |
| | 925 | selectors.time.push(function(date) { return [true]; }); |
| | 926 | } |
| | 927 | |
| | 928 | // normalize minutes into range |
| | 929 | // XXX: what if it's further than tomorrow? |
| | 930 | // XXX: this is incorrect, as it assumes the same day |
| | 931 | // should cooperate with date selectors to select the next day |
| | 932 | if (minutes_from >= minutes_in_day) |
| | 933 | throw formatWarnErrorMessage(nblock, at_end_time + (has_normal_time[1] ? 3 : (has_time_var_calc[1] ? 7 : 1)) - 1, |
| | 934 | 'Time range starts outside of the current day'); |
| | 935 | if (minutes_to < minutes_from || ((has_normal_time[0] && has_normal_time[1]) && minutes_from == minutes_to)) |
| | 936 | minutes_to += minutes_in_day; |
| | 937 | if (minutes_to > minutes_in_day * 2) |
| | 938 | throw formatWarnErrorMessage(nblock, at_end_time + (has_normal_time[1] ? 3 : (has_time_var_calc[1] ? 7 : 1)) - 1, |
| | 939 | 'Time spanning more than two midnights not supported'); |
| | 940 | |
| | 941 | var timevar_string = []; |
| | 942 | if (typeof lat != 'undefined') { // lon will also be defined (see above) |
| | 943 | if ((!has_normal_time[0] || !has_normal_time[1]) && !has_open_end) |
| | 944 | week_stable = false; |
| | 945 | if (!has_normal_time[0]) |
| | 946 | timevar_string[0] = tokens[at+has_time_var_calc[0]][0]; |
| | 947 | if (!has_normal_time[1] && !has_open_end) |
| | 948 | timevar_string[1] = tokens[at_end_time+has_time_var_calc[1]][0] |
| | 949 | } // else: we can not calculate exact times so we use the already applied constants (word_value_replacement). |
| | 950 | |
| | 951 | if (minutes_to > minutes_in_day) { // has_normal_time[1] must be true |
| | 952 | selectors.time.push(function(minutes_from, minutes_to, timevar_string, timevar_add, has_open_end) { return function(date) { |
| | 953 | var ourminutes = date.getHours() * 60 + date.getMinutes(); |
| | 954 | |
| | 955 | if (timevar_string[0]) { |
| | 956 | var date_from = eval('SunCalc.getTimes(date, lat, lon).' + timevar_string[0]); |
| | 957 | minutes_from = date_from.getHours() * 60 + date_from.getMinutes() + timevar_add[0]; |
| | 958 | } |
| | 959 | if (timevar_string[1]) { |
| | 960 | var date_to = eval('SunCalc.getTimes(date, lat, lon).' + timevar_string[1]); |
| | 961 | minutes_to = date_to.getHours() * 60 + date_to.getMinutes() + timevar_add[1]; |
| | 962 | minutes_to += minutes_in_day; |
| | 963 | // Needs to be added because it was added by |
| | 964 | // normal times in: if (minutes_to < // minutes_from) |
| | 965 | // above the selector construction. |
| | 966 | } |
| | 967 | |
| | 968 | if (ourminutes < minutes_from) |
| | 969 | return [false, dateAtDayMinutes(date, minutes_from)]; |
| | 970 | else |
| | 971 | return [true, dateAtDayMinutes(date, minutes_to), has_open_end]; |
| | 972 | }}(minutes_from, minutes_to, timevar_string, timevar_add, has_open_end)); |
| | 973 | |
| | 974 | selectors.wraptime.push(function(minutes_from, minutes_to, timevar_string, timevar_add, has_open_end) { return function(date) { |
| | 975 | var ourminutes = date.getHours() * 60 + date.getMinutes(); |
| | 976 | |
| | 977 | if (timevar_string[0]) { |
| | 978 | var date_from = eval('SunCalc.getTimes(date, lat, lon).' + timevar_string[0]); |
| | 979 | minutes_from = date_from.getHours() * 60 + date_from.getMinutes() + timevar_add[0]; |
| | 980 | } |
| | 981 | if (timevar_string[1]) { |
| | 982 | var date_to = eval('SunCalc.getTimes(date, lat, lon).' + timevar_string[1]); |
| | 983 | minutes_to = date_to.getHours() * 60 + date_to.getMinutes() + timevar_add[1]; |
| | 984 | // minutes_in_day does not need to be added. |
| | 985 | // For normal times in it was added in: if (minutes_to < // minutes_from) |
| | 986 | // above the selector construction and |
| | 987 | // subtracted in the selector construction call |
| | 988 | // which returns the selector function. |
| | 989 | } |
| | 990 | |
| | 991 | if (ourminutes < minutes_to) |
| | 992 | return [true, dateAtDayMinutes(date, minutes_to), has_open_end]; |
| | 993 | else |
| | 994 | return [false, undefined]; |
| | 995 | }}(minutes_from, minutes_to - minutes_in_day, timevar_string, timevar_add, has_open_end)); |
| | 996 | } else { |
| | 997 | selectors.time.push(function(minutes_from, minutes_to, timevar_string, timevar_add, has_open_end) { return function(date) { |
| | 998 | var ourminutes = date.getHours() * 60 + date.getMinutes(); |
| | 999 | |
| | 1000 | if (timevar_string[0]) { |
| | 1001 | var date_from = eval('SunCalc.getTimes(date, lat, lon).' + timevar_string[0]); |
| | 1002 | minutes_from = date_from.getHours() * 60 + date_from.getMinutes() + timevar_add[0]; |
| | 1003 | } |
| | 1004 | if (timevar_string[1]) { |
| | 1005 | var date_to = eval('SunCalc.getTimes(date, lat, lon).' + timevar_string[1]); |
| | 1006 | minutes_to = date_to.getHours() * 60 + date_to.getMinutes() + timevar_add[1]; |
| | 1007 | } |
| | 1008 | |
| | 1009 | if (ourminutes < minutes_from) |
| | 1010 | return [false, dateAtDayMinutes(date, minutes_from)]; |
| | 1011 | else if (ourminutes < minutes_to) |
| | 1012 | return [true, dateAtDayMinutes(date, minutes_to), has_open_end]; |
| | 1013 | else |
| | 1014 | return [false, dateAtDayMinutes(date, minutes_from + minutes_in_day)]; |
| | 1015 | }}(minutes_from, minutes_to, timevar_string, timevar_add, has_open_end)); |
| | 1016 | } |
| | 1017 | |
| | 1018 | at = at_end_time + (has_normal_time[1] ? 3 : (has_time_var_calc[1] ? 7 : !has_open_end)); |
| | 1019 | } else { // additional block |
| | 1020 | if (matchTokens(tokens, at, '(')) |
| | 1021 | throw formatWarnErrorMessage(nblock, at+1, 'Missing variable time (e.g. sunrise) after: "' + tokens[at][1] + '"'); |
| | 1022 | if (matchTokens(tokens, at, 'number', 'timesep')) |
| | 1023 | throw formatWarnErrorMessage(nblock, at+2, 'Missing minutes in time range after: "' + tokens[at+1][1] + '"'); |
| | 1024 | if (matchTokens(tokens, at, 'number')) |
| | 1025 | throw formatWarnErrorMessage(nblock, at+2, 'Missing time seperator in time range after: "' + tokens[at][1] + '"'); |
| | 1026 | return [ at ]; |
| | 1027 | } |
| | 1028 | |
| | 1029 | if (!matchTokens(tokens, at, ',')) |
| | 1030 | break; |
| | 1031 | } |
| | 1032 | |
| | 1033 | return at; |
| | 1034 | } |
| | 1035 | |
| | 1036 | // for given date, returns date moved to the start of specified day minute |
| | 1037 | function dateAtDayMinutes(date, minutes) { |
| | 1038 | return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, minutes); |
| | 1039 | } |
| | 1040 | |
| | 1041 | // extract the added or subtracted time of "(sunrise-01:30)" |
| | 1042 | // returns in minutes e.g. -90 |
| | 1043 | function parseTimevarCalc(tokens, at) { |
| | 1044 | if (matchTokens(tokens, at+2, '+') || matchTokens(tokens, at+2, '-')) { |
| | 1045 | if (matchTokens(tokens, at+3, 'number', 'timesep', 'number')) { |
| | 1046 | if (matchTokens(tokens, at+6, ')')) { |
| | 1047 | var add_or_subtract = tokens[at+2][0] == '+' ? '1' : '-1'; |
| | 1048 | return (tokens[at+3][0] * 60 + tokens[at+5][0]) * add_or_subtract; |
| | 1049 | } else { |
| | 1050 | error = [ at+6, '. Missing ")".']; |
| | 1051 | } |
| | 1052 | } else { |
| | 1053 | error = [ at+5, ' (time).']; |
| | 1054 | } |
| | 1055 | } else { |
| | 1056 | error = [ at+2, '. "+" or "-" expected.']; |
| | 1057 | } |
| | 1058 | |
| | 1059 | if (error) |
| | 1060 | throw formatWarnErrorMessage(nblock, error[0], |
| | 1061 | 'Calculcation with variable time is not in the right syntax' + error[1]); |
| | 1062 | } |
| | 1063 | |
| | 1064 | //====================================================================== |
| | 1065 | // Weekday range parser (Mo,We-Fr,Sa[1-2,-1]) |
| | 1066 | //====================================================================== |
| | 1067 | function parseWeekdayRange(tokens, at, selectors) { |
| | 1068 | for (; at < tokens.length; at++) { |
| | 1069 | if (matchTokens(tokens, at, 'weekday', '[')) { |
| | 1070 | // Conditional weekday (Mo[3]) |
| | 1071 | var numbers = []; |
| | 1072 | |
| | 1073 | // Get list of constraints |
| | 1074 | var endat = parseNumRange(tokens, at+2, function(from, to, at) { |
| | 1075 | |
| | 1076 | // bad number |
| | 1077 | if (from == 0 || from < -5 || from > 5) |
| | 1078 | throw formatWarnErrorMessage(nblock, at, |
| | 1079 | 'Number between -5 and 5 (except 0) expected'); |
| | 1080 | |
| | 1081 | if (from == to) { |
| | 1082 | numbers.push(from); |
| | 1083 | } else if (from < to) { |
| | 1084 | for (var i = from; i <= to; i++) { |
| | 1085 | // bad number |
| | 1086 | if (i == 0 || i < -5 || i > 5) |
| | 1087 | throw formatWarnErrorMessage(nblock, at+2, |
| | 1088 | 'Number between -5 and 5 (except 0) expected.'); |
| | 1089 | |
| | 1090 | numbers.push(i); |
| | 1091 | } |
| | 1092 | } else { |
| | 1093 | throw formatWarnErrorMessage(nblock, at+2, |
| | 1094 | 'Bad range: ' + from + '-' + to); |
| | 1095 | } |
| | 1096 | }); |
| | 1097 | |
| | 1098 | if (!matchTokens(tokens, endat, ']')) |
| | 1099 | throw formatWarnErrorMessage(nblock, endat, '"]" or more numbers expected.'); |
| | 1100 | |
| | 1101 | var add_days = getMoveDays(tokens, endat+1, 6, 'constrained weekdays'); |
| | 1102 | week_stable = false; |
| | 1103 | |
| | 1104 | // Create selector for each list element |
| | 1105 | for (var nnumber = 0; nnumber < numbers.length; nnumber++) { |
| | 1106 | |
| | 1107 | selectors.weekday.push(function(weekday, number, add_days) { return function(date) { |
| | 1108 | var date_num = getValueForDate(date, false); // Year not needed to distinguish. |
| | 1109 | var start_of_this_month = new Date(date.getFullYear(), date.getMonth(), 1); |
| | 1110 | var start_of_next_month = new Date(date.getFullYear(), date.getMonth() + 1, 1); |
| | 1111 | |
| | 1112 | var target_day_this_month; |
| | 1113 | |
| | 1114 | target_day_this_month = dateAtNextWeekday( |
| | 1115 | new Date(date.getFullYear(), date.getMonth() + (number > 0 ? 0 : 1), 1), weekday); |
| | 1116 | target_day_this_month.setDate(target_day_this_month.getDate() + (number + (number > 0 ? -1 : 0)) * 7); |
| | 1117 | |
| | 1118 | var target_day_with_added_days_this_month = new Date(target_day_this_month.getFullYear(), |
| | 1119 | target_day_this_month.getMonth(), target_day_this_month.getDate() + add_days); |
| | 1120 | |
| | 1121 | |
| | 1122 | // The target day with added days can be before this month |
| | 1123 | if (target_day_with_added_days_this_month.getTime() < start_of_this_month.getTime()) { |
| | 1124 | // but in this case, the target day without the days added needs to be in this month |
| | 1125 | if (target_day_this_month.getTime() >= start_of_this_month.getTime()) { |
| | 1126 | // so we calculate it for the month |
| | 1127 | // following this month and hope that the |
| | 1128 | // target day will actually be this month. |
| | 1129 | |
| | 1130 | target_day_with_added_days_this_month = dateAtNextWeekday( |
| | 1131 | new Date(date.getFullYear(), date.getMonth() + (number > 0 ? 0 : 1) + 1, 1), weekday); |
| | 1132 | target_day_this_month.setDate(target_day_with_added_days_this_month.getDate() |
| | 1133 | + (number + (number > 0 ? -1 : 0)) * 7 + add_days); |
| | 1134 | } else { |
| | 1135 | // Calculated target day is not inside this month |
| | 1136 | // therefore the specified weekday (e.g. fifth Sunday) |
| | 1137 | // does not exist this month. Try it next month. |
| | 1138 | return [false, start_of_next_month]; |
| | 1139 | } |
| | 1140 | } else if (target_day_with_added_days_this_month.getTime() >= start_of_next_month.getTime()) { |
| | 1141 | // The target day is in the next month. If the target day without the added days is not in this month |
| | 1142 | if (target_day_this_month.getTime() >= start_of_next_month.getTime()) |
| | 1143 | return [false, start_of_next_month]; |
| | 1144 | } |
| | 1145 | |
| | 1146 | if (add_days > 0) { |
| | 1147 | var target_day_with_added_moved_days_this_month = dateAtNextWeekday( |
| | 1148 | new Date(date.getFullYear(), date.getMonth() + (number > 0 ? 0 : 1) -1, 1), weekday); |
| | 1149 | target_day_with_added_moved_days_this_month.setDate(target_day_with_added_moved_days_this_month.getDate() |
| | 1150 | + (number + (number > 0 ? -1 : 0)) * 7 + add_days); |
| | 1151 | |
| | 1152 | if (date_num == getValueForDate(target_day_with_added_moved_days_this_month, false)) |
| | 1153 | return [true, dateAtDayMinutes(date, minutes_in_day)]; |
| | 1154 | } else if (add_days < 0) { |
| | 1155 | var target_day_with_added_moved_days_this_month = dateAtNextWeekday( |
| | 1156 | new Date(date.getFullYear(), date.getMonth() + (number > 0 ? 0 : 1) + 1, 1), weekday); |
| | 1157 | target_day_with_added_moved_days_this_month.setDate(target_day_with_added_moved_days_this_month.getDate() |
| | 1158 | + (number + (number > 0 ? -1 : 0)) * 7 + add_days); |
| | 1159 | |
| | 1160 | if (target_day_with_added_moved_days_this_month.getTime() >= start_of_next_month.getTime()) { |
| | 1161 | if (target_day_with_added_days_this_month.getTime() >= start_of_next_month.getTime()) |
| | 1162 | return [false, target_day_with_added_moved_days_this_month]; |
| | 1163 | } else { |
| | 1164 | if (target_day_with_added_days_this_month.getTime() < start_of_next_month.getTime() |
| | 1165 | && getValueForDate(target_day_with_added_days_this_month, false) == date_num) |
| | 1166 | return [true, dateAtDayMinutes(date, minutes_in_day)]; |
| | 1167 | |
| | 1168 | target_day_with_added_days_this_month = target_day_with_added_moved_days_this_month; |
| | 1169 | } |
| | 1170 | } |
| | 1171 | |
| | 1172 | // we hit the target day |
| | 1173 | if (date.getDate() == target_day_with_added_days_this_month.getDate()) { |
| | 1174 | return [true, dateAtDayMinutes(date, minutes_in_day)]; |
| | 1175 | } |
| | 1176 | |
| | 1177 | // we're before target day |
| | 1178 | if (date.getDate() < target_day_with_added_days_this_month.getDate()) { |
| | 1179 | return [false, target_day_with_added_days_this_month]; |
| | 1180 | } |
| | 1181 | |
| | 1182 | // we're after target day, set check date to next month |
| | 1183 | return [false, start_of_next_month]; |
| | 1184 | }}(tokens[at][0], numbers[nnumber], add_days[0])); |
| | 1185 | } |
| | 1186 | |
| | 1187 | at = endat + 1 + add_days[1] * 3; |
| | 1188 | } else if (matchTokens(tokens, at, 'weekday')) { |
| | 1189 | // Single weekday (Mo) or weekday range (Mo-Fr) |
| | 1190 | var is_range = matchTokens(tokens, at+1, '-', 'weekday'); |
| | 1191 | |
| | 1192 | var weekday_from = tokens[at][0]; |
| | 1193 | var weekday_to = is_range ? tokens[at+2][0] : weekday_from; |
| | 1194 | |
| | 1195 | var inside = true; |
| | 1196 | |
| | 1197 | // handle reversed range |
| | 1198 | if (weekday_to < weekday_from) { |
| | 1199 | var tmp = weekday_to; |
| | 1200 | weekday_to = weekday_from - 1; |
| | 1201 | weekday_from = tmp + 1; |
| | 1202 | inside = false; |
| | 1203 | } |
| | 1204 | |
| | 1205 | if (weekday_to < weekday_from) { |
| | 1206 | // handle full range |
| | 1207 | selectors.weekday.push(function(date) { return [true]; }); |
| | 1208 | } else { |
| | 1209 | selectors.weekday.push(function(weekday_from, weekday_to, inside) { return function(date) { |
| | 1210 | var ourweekday = date.getDay(); |
| | 1211 | |
| | 1212 | if (ourweekday < weekday_from || ourweekday > weekday_to) { |
| | 1213 | return [!inside, dateAtNextWeekday(date, weekday_from)]; |
| | 1214 | } else { |
| | 1215 | return [inside, dateAtNextWeekday(date, weekday_to + 1)]; |
| | 1216 | } |
| | 1217 | }}(weekday_from, weekday_to, inside)); |
| | 1218 | } |
| | 1219 | |
| | 1220 | at += is_range ? 3 : 1; |
| | 1221 | } else if (matchTokens(tokens, at, 'holiday')) { |
| | 1222 | week_stable = false; |
| | 1223 | return parseHoliday(tokens, at, selectors, true); |
| | 1224 | } else { |
| | 1225 | throw formatWarnErrorMessage(nblock, at, 'Unexpected token in weekday range: ' + tokens[at][1]); |
| | 1226 | } |
| | 1227 | |
| | 1228 | if (!matchTokens(tokens, at, ',')) |
| | 1229 | break; |
| | 1230 | } |
| | 1231 | |
| | 1232 | return at; |
| | 1233 | } |
| | 1234 | |
| | 1235 | // Numeric list parser (1,2,3-4,-1), used in weekday parser above |
| | 1236 | function parseNumRange(tokens, at, func) { |
| | 1237 | for (; at < tokens.length; at++) { |
| | 1238 | if (matchTokens(tokens, at, 'number', '-', 'number')) { |
| | 1239 | // Number range |
| | 1240 | func(tokens[at][0], tokens[at+2][0], at); |
| | 1241 | at += 3; |
| | 1242 | } else if (matchTokens(tokens, at, '-', 'number')) { |
| | 1243 | // Negative number |
| | 1244 | func(-tokens[at+1][0], -tokens[at+1][0], at); |
| | 1245 | at += 2 |
| | 1246 | } else if (matchTokens(tokens, at, 'number')) { |
| | 1247 | // Single number |
| | 1248 | func(tokens[at][0], tokens[at][0], at); |
| | 1249 | at++; |
| | 1250 | } else { |
| | 1251 | throw formatWarnErrorMessage(nblock, at + matchTokens(tokens, at, '-'), |
| | 1252 | 'Unexpected token in number range: ' + tokens[at][1]); |
| | 1253 | } |
| | 1254 | |
| | 1255 | if (!matchTokens(tokens, at, ',')) |
| | 1256 | break; |
| | 1257 | } |
| | 1258 | |
| | 1259 | return at; |
| | 1260 | } |
| | 1261 | |
| | 1262 | function getMoveDays(tokens, at, max_differ, name) { |
| | 1263 | var add_days = [ 0, false ]; |
| | 1264 | add_days[0] = matchTokens(tokens, at, '+') || (matchTokens(tokens, at, '-') ? -1 : 0); |
| | 1265 | if (add_days[0] != 0 && matchTokens(tokens, at+1, 'number', 'calcday')) { |
| | 1266 | // continues with '+ 5 days' or something like that |
| | 1267 | if (tokens[at+1][0] > max_differ) |
| | 1268 | throw formatWarnErrorMessage(nblock, at+2, |
| | 1269 | 'There should be no reason to differ more than ' + max_differ + ' days from a ' + name + '. If so tell us …'); |
| | 1270 | add_days[0] *= tokens[at+1][0]; |
| | 1271 | if (add_days[0] == 0) |
| | 1272 | parsing_warnings.push([ nblock, at+2, 'Adding 0 does not change the date. Please omit this.' ]); |
| | 1273 | add_days[1] = true; |
| | 1274 | } else { |
| | 1275 | add_days[0] = 0; |
| | 1276 | } |
| | 1277 | return add_days; |
| | 1278 | } |
| | 1279 | |
| | 1280 | |
| | 1281 | // for given date, returns date moved to the specific day of week |
| | 1282 | function dateAtNextWeekday(date, day) { |
| | 1283 | var delta = day - date.getDay(); |
| | 1284 | return new Date(date.getFullYear(), date.getMonth(), date.getDate() + delta + (delta < 0 ? 7 : 0)); |
| | 1285 | } |
| | 1286 | |
| | 1287 | //====================================================================== |
| | 1288 | // Holiday parser for public and school holidays (PH,SH) |
| | 1289 | // push_to_weekday will push the selector into the weekday selector array which has the desired side effect of working in conjunction with the weekday selectors (either the holiday match or the weekday), which is the normal and expected behavior. |
| | 1290 | //====================================================================== |
| | 1291 | function parseHoliday(tokens, at, selectors, push_to_weekday) { |
| | 1292 | for (; at < tokens.length; at++) { |
| | 1293 | if (matchTokens(tokens, at, 'holiday')) { |
| | 1294 | if (tokens[at][0] == 'PH') { |
| | 1295 | var applying_holidays = getMatchingHoliday(tokens[at][0]); |
| | 1296 | |
| | 1297 | // Only allow moving one day in the past or in the future. |
| | 1298 | // This makes implementation easier because only one holiday is assumed to be moved to the next year. |
| | 1299 | var add_days = getMoveDays(tokens, at+1, 1, 'public holiday'); |
| | 1300 | |
| | 1301 | var selector = function(applying_holidays, add_days) { return function(date) { |
| | 1302 | |
| | 1303 | var holidays = getApplyingHolidaysForYear(applying_holidays, date.getFullYear(), add_days); |
| | 1304 | // Needs to be calculated each time because of movable days. |
| | 1305 | |
| | 1306 | var date_num = getValueForDate(date, true); |
| | 1307 | |
| | 1308 | for (var i = 0; i < holidays.length; i++) { |
| | 1309 | var next_holiday_date_num = getValueForDate(holidays[i][0], true); |
| | 1310 | |
| | 1311 | if (date_num < next_holiday_date_num) { |
| | 1312 | |
| | 1313 | if (add_days[0] > 0) { |
| | 1314 | // Calculate the last holiday from previous year to tested against it. |
| | 1315 | var holidays_last_year = getApplyingHolidaysForYear(applying_holidays, date.getFullYear() - 1, add_days); |
| | 1316 | var last_holiday_last_year = holidays_last_year[holidays_last_year.length - 1]; |
| | 1317 | var last_holiday_last_year_num = getValueForDate(last_holiday_last_year[0], true); |
| | 1318 | |
| | 1319 | if (date_num < last_holiday_last_year_num ) { |
| | 1320 | return [ false, last_holiday_last_year[0] ]; |
| | 1321 | } else if (date_num == last_holiday_last_year_num) { |
| | 1322 | return [true, dateAtDayMinutes(last_holiday_last_year[0], minutes_in_day), |
| | 1323 | 'Day after ' +last_holiday_last_year[1] ]; |
| | 1324 | } |
| | 1325 | } |
| | 1326 | |
| | 1327 | return [ false, holidays[i][0] ]; |
| | 1328 | } else if (date_num == next_holiday_date_num) { |
| | 1329 | return [true, new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1), |
| | 1330 | (add_days[0] > 0 ? 'Day after ' : (add_days[0] < 0 ? 'Day before ' : '')) + holidays[i][1] ]; |
| | 1331 | } |
| | 1332 | } |
| | 1333 | |
| | 1334 | if (add_days[0] < 0) { |
| | 1335 | // Calculate the first holiday from next year to tested against it. |
| | 1336 | var holidays_next_year = getApplyingHolidaysForYear(applying_holidays, date.getFullYear() + 1, add_days); |
| | 1337 | var first_holidays_next_year = holidays_next_year[0]; |
| | 1338 | var first_holidays_next_year_num = getValueForDate(first_holidays_next_year[0], true); |
| | 1339 | if (date_num == first_holidays_next_year_num) { |
| | 1340 | return [true, dateAtDayMinutes(first_holidays_next_year[0], minutes_in_day), |
| | 1341 | 'Day before ' + first_holidays_next_year[1] ]; |
| | 1342 | } |
| | 1343 | } |
| | 1344 | |
| | 1345 | // continue next year |
| | 1346 | return [ false, new Date(holidays[0][0].getFullYear() + 1, |
| | 1347 | holidays[0][0].getMonth(), |
| | 1348 | holidays[0][0].getDate()) ]; |
| | 1349 | |
| | 1350 | }}(applying_holidays, add_days); |
| | 1351 | |
| | 1352 | if (push_to_weekday) |
| | 1353 | selectors.weekday.push(selector); |
| | 1354 | else |
| | 1355 | selectors.holiday.push(selector); |
| | 1356 | |
| | 1357 | at += 1 + add_days[1] * 3; |
| | 1358 | } else if (tokens[at][0] == 'SH') { |
| | 1359 | var applying_holidays = getMatchingHoliday(tokens[at][0]); |
| | 1360 | |
| | 1361 | var holidays = []; // needs to be sorted each time because of movable days |
| | 1362 | |
| | 1363 | var selector = function(applying_holidays) { return function(date) { |
| | 1364 | var date_num = getValueForDate(date); |
| | 1365 | |
| | 1366 | // Iterate over holiday array containing the different holiday ranges. |
| | 1367 | for (var i = 0; i < applying_holidays.length; i++) { |
| | 1368 | |
| | 1369 | var holiday = getSHForYear(applying_holidays[i], date.getFullYear()); |
| | 1370 | |
| | 1371 | for (var h = 0; h < holiday.length; h+=4) { |
| | 1372 | var holiday_to_plus = new Date(date.getFullYear(), holiday[2+h] - 1, holiday[3+h] + 1); |
| | 1373 | var holiday_from = (holiday[0+h] - 1) * 100 + holiday[1+h]; |
| | 1374 | var holiday_to = (holiday[2+h] - 1) * 100 + holiday[3+h]; |
| | 1375 | holiday_to_plus = getValueForDate(holiday_to_plus); |
| | 1376 | |
| | 1377 | var holiday_ends_next_year = holiday_to < holiday_from; |
| | 1378 | |
| | 1379 | if (date_num < holiday_from) { // date is before selected holiday |
| | 1380 | |
| | 1381 | // check if we are in the holidays from the last year spanning into this year |
| | 1382 | var last_year_holiday = getSHForYear(applying_holidays[applying_holidays.length - 1], date.getFullYear() - 1, false); |
| | 1383 | if (typeof last_year_holiday != 'undefined') { |
| | 1384 | var last_year_holiday_from = (last_year_holiday[last_year_holiday.length - 4] - 1) * 100 |
| | 1385 | + last_year_holiday[last_year_holiday.length - 3]; // e.g. 1125 |
| | 1386 | var last_year_holiday_to = (last_year_holiday[last_year_holiday.length - 2] - 1) * 100 |
| | 1387 | + last_year_holiday[last_year_holiday.length - 1]; // e.g. 0005 |
| | 1388 | |
| | 1389 | if (last_year_holiday_to < last_year_holiday_from && date_num < last_year_holiday_to) |
| | 1390 | return [ true, new Date(date.getFullYear(), |
| | 1391 | last_year_holiday[last_year_holiday.length - 2] - 1, |
| | 1392 | last_year_holiday[last_year_holiday.length - 1] + 1), |
| | 1393 | applying_holidays[applying_holidays.length - 1].name ]; |
| | 1394 | else |
| | 1395 | return [ false, new Date(date.getFullYear(), holiday[0+h] - 1, holiday[1+h]) ]; |
| | 1396 | } else { // school holidays for last year are not defined. |
| | 1397 | return [ false, new Date(date.getFullYear(), holiday[0+h] - 1, holiday[1+h]) ]; |
| | 1398 | } |
| | 1399 | } else if (holiday_from <= date_num && (date_num < holiday_to_plus || holiday_ends_next_year)) { |
| | 1400 | return [ true, new Date(date.getFullYear() + holiday_ends_next_year, holiday[2+h] - 1, holiday[3+h] + 1), |
| | 1401 | applying_holidays[i].name ]; |
| | 1402 | } else if (holiday_to_plus == date_num) { // selected holiday end is equal to month and day |
| | 1403 | if (h + 4 < holiday.length) { // next holiday is next date range of the same holidays |
| | 1404 | h += 4; |
| | 1405 | return [ false, new Date(date.getFullYear(), holiday[0+h] - 1, holiday[1+h]) ]; |
| | 1406 | } else { |
| | 1407 | if (i + 1 == applying_holidays.length) { // last holidays are handled, continue all over again |
| | 1408 | var holiday = getSHForYear(applying_holidays[0], date.getFullYear() + 1); |
| | 1409 | return [ false, new Date(date.getFullYear() + !holiday_ends_next_year, holiday[0+h] - 1, holiday[1+h]) ]; |
| | 1410 | } else { // return the start of the next holidays |
| | 1411 | var holiday = getSHForYear(applying_holidays[i+1], date.getFullYear()); |
| | 1412 | return [ false, new Date(date.getFullYear(), holiday[0] - 1, holiday[1]) ]; |
| | 1413 | } |
| | 1414 | } |
| | 1415 | } |
| | 1416 | } |
| | 1417 | } |
| | 1418 | return [ false ]; |
| | 1419 | }}(applying_holidays); |
| | 1420 | |
| | 1421 | if (push_to_weekday) |
| | 1422 | selectors.weekday.push(selector); |
| | 1423 | else |
| | 1424 | selectors.holiday.push(selector); |
| | 1425 | at += 1; |
| | 1426 | } |
| | 1427 | } else if (matchTokens(tokens, at, 'weekday')) { |
| | 1428 | return parseWeekdayRange(tokens, at, selectors); |
| | 1429 | } else { |
| | 1430 | throw formatWarnErrorMessage(nblock, at, 'Unexpected token (school holiday parser): ' + tokens[at][1]); |
| | 1431 | } |
| | 1432 | |
| | 1433 | if (!matchTokens(tokens, at, ',')) |
| | 1434 | break; |
| | 1435 | } |
| | 1436 | |
| | 1437 | return at; |
| | 1438 | } |
| | 1439 | |
| | 1440 | // Returns a number for a date which can then be used to compare just the dates (without the time). |
| | 1441 | // This is necessary because a selector could be called for the middle of the day and we need to tell if it matches that day. |
| | 1442 | // Example: Returns 20150015 for Jan 01 2015 |
| | 1443 | function getValueForDate(date, include_year) { |
| | 1444 | // Implicit because undefined evaluates to false |
| | 1445 | // include_year = typeof include_year != 'undefined' ? include_year : false; |
| | 1446 | |
| | 1447 | return (include_year ? date.getFullYear() * 10000 : 0) + date.getMonth() * 100 + date.getDate(); |
| | 1448 | } |
| | 1449 | |
| | 1450 | // return the school holiday definition e.g. [ 5, 25, /* to */ 6, 5 ], |
| | 1451 | // for the specified year |
| | 1452 | function getSHForYear(SH_hash, year, fatal) { |
| | 1453 | if (typeof fatal == 'undefined') |
| | 1454 | fatal = true; |
| | 1455 | |
| | 1456 | var holiday = SH_hash[year]; |
| | 1457 | if (typeof holiday == 'undefined') { |
| | 1458 | holiday = SH_hash['default']; // applies for any year without explicit definition |
| | 1459 | if (typeof holiday == 'undefined') { |
| | 1460 | if (fatal) { |
| | 1461 | throw 'School holiday ' + SH_hash.name + ' has no definition for the year ' + year + '.'; |
| | 1462 | } else { |
| | 1463 | return undefined; |
| | 1464 | } |
| | 1465 | } |
| | 1466 | } |
| | 1467 | return holiday; |
| | 1468 | } |
| | 1469 | |
| | 1470 | // Return closed holiday definition available. |
| | 1471 | // First try to get the state, if missing get the country wide holidays |
| | 1472 | // (which can be limited to some states). |
| | 1473 | function getMatchingHoliday(type_of_holidays) { |
| | 1474 | if (typeof location_cc != 'undefined') { |
| | 1475 | if (holidays.hasOwnProperty(location_cc)) { |
| | 1476 | if (typeof location_state != 'undefined') { |
| | 1477 | if (holidays[location_cc][location_state] |
| | 1478 | && holidays[location_cc][location_state][type_of_holidays]) { |
| | 1479 | // if holidays for the state are specified use it |
| | 1480 | // and ignore lesser specific ones (for the country) |
| | 1481 | return holidays[location_cc][location_state][type_of_holidays]; |
| | 1482 | } else if (holidays[location_cc][type_of_holidays]) { |
| | 1483 | // holidays are only defined country wide |
| | 1484 | matching_holiday = {}; // holidays in the country wide scope can be limited to certain states |
| | 1485 | for (var holiday_name in holidays[location_cc][type_of_holidays]) { |
| | 1486 | if (typeof holidays[location_cc][type_of_holidays][holiday_name][2] === 'object') { |
| | 1487 | if (-1 != indexOf.call(holidays[location_cc][type_of_holidays][holiday_name][2], location_state)) |
| | 1488 | matching_holiday[holiday_name] = holidays[location_cc][type_of_holidays][holiday_name]; |
| | 1489 | } else { |
| | 1490 | matching_holiday[holiday_name] = holidays[location_cc][type_of_holidays][holiday_name]; |
| | 1491 | } |
| | 1492 | } |
| | 1493 | if (Object.keys(matching_holiday).length == 0) |
| | 1494 | throw 'There are no holidays ' + type_of_holidays + ' defined for country ' + location_cc + '.' |
| | 1495 | + ' Please add them.'; |
| | 1496 | return matching_holiday; |
| | 1497 | } else { |
| | 1498 | throw 'Holidays ' + type_of_holidays + ' are not defined for country ' + location_cc |
| | 1499 | + ' and state ' + location_state + '.' |
| | 1500 | + ' Please add them.'; |
| | 1501 | } |
| | 1502 | } |
| | 1503 | } else { |
| | 1504 | throw 'No holidays are defined for country ' + location_cc + '. Please add them.'; |
| | 1505 | } |
| | 1506 | } else { // we have no idea which holidays do apply because the country code was not provided |
| | 1507 | throw 'Country code missing which is needed to select the correct holidays (see README how to provide it)' |
| | 1508 | } |
| | 1509 | } |
| | 1510 | |
| | 1511 | function getMovableEventsForYear(Y) { |
| | 1512 | // calculate easter |
| | 1513 | var C = Math.floor(Y/100); |
| | 1514 | var N = Y - 19*Math.floor(Y/19); |
| | 1515 | var K = Math.floor((C - 17)/25); |
| | 1516 | var I = C - Math.floor(C/4) - Math.floor((C - K)/3) + 19*N + 15; |
| | 1517 | I = I - 30*Math.floor((I/30)); |
| | 1518 | I = I - Math.floor(I/28)*(1 - Math.floor(I/28)*Math.floor(29/(I + 1))*Math.floor((21 - N)/11)); |
| | 1519 | var J = Y + Math.floor(Y/4) + I + 2 - C + Math.floor(C/4); |
| | 1520 | J = J - 7*Math.floor(J/7); |
| | 1521 | var L = I - J; |
| | 1522 | var M = 3 + Math.floor((L + 40)/44); |
| | 1523 | var D = L + 28 - 31*Math.floor(M/4); |
| | 1524 | |
| | 1525 | return { |
| | 1526 | 'easter': new Date(Y, M - 1, D), |
| | 1527 | }; |
| | 1528 | } |
| | 1529 | |
| | 1530 | function indexOf(needle) { |
| | 1531 | if(typeof Array.prototype.indexOf === 'function') { |
| | 1532 | indexOf = Array.prototype.indexOf; |
| | 1533 | } else { |
| | 1534 | indexOf = function(needle) { |
| | 1535 | var i = -1, index = -1; |
| | 1536 | for(i = 0; i < this.length; i++) { |
| | 1537 | if(this[i] === needle) { |
| | 1538 | index = i; |
| | 1539 | break; |
| | 1540 | } |
| | 1541 | } |
| | 1542 | return index; |
| | 1543 | }; |
| | 1544 | } |
| | 1545 | return indexOf.call(this, needle); |
| | 1546 | } |
| | 1547 | |
| | 1548 | function getApplyingHolidaysForYear(applying_holidays, year, add_days) { |
| | 1549 | var movableDays = getMovableEventsForYear(year); |
| | 1550 | |
| | 1551 | var sorted_holidays = []; |
| | 1552 | |
| | 1553 | for (var holiday_name in applying_holidays) { |
| | 1554 | if (typeof applying_holidays[holiday_name][0] == 'string') { |
| | 1555 | var selected_movableDay = movableDays[applying_holidays[holiday_name][0]]; |
| | 1556 | if (!selected_movableDay) |
| | 1557 | throw 'Movable day ' + applying_holidays[holiday_name][0] + ' can not not be calculated.' |
| | 1558 | + ' Please add the formula how to calculate it.'; |
| | 1559 | var next_holiday = new Date(selected_movableDay.getFullYear(), |
| | 1560 | selected_movableDay.getMonth(), |
| | 1561 | selected_movableDay.getDate() |
| | 1562 | + applying_holidays[holiday_name][1] |
| | 1563 | ); |
| | 1564 | if (year != next_holiday.getFullYear()) |
| | 1565 | throw 'The movable day ' + applying_holidays[holiday_name][0] + ' plus ' |
| | 1566 | + applying_holidays[holiday_name][1] |
| | 1567 | + ' days is not in the year of the movable day anymore. Currently not supported.'; |
| | 1568 | } else { |
| | 1569 | var next_holiday = new Date(year, |
| | 1570 | applying_holidays[holiday_name][0] - 1, |
| | 1571 | applying_holidays[holiday_name][1] |
| | 1572 | ); |
| | 1573 | } |
| | 1574 | if (add_days[1]) { |
| | 1575 | next_holiday.setDate(next_holiday.getDate() + add_days[0]); |
| | 1576 | } |
| | 1577 | |
| | 1578 | sorted_holidays.push([ next_holiday, holiday_name ]); |
| | 1579 | } |
| | 1580 | |
| | 1581 | sorted_holidays = sorted_holidays.sort(function(a,b){ |
| | 1582 | if (a[0].getTime() < b[0].getTime()) return -1; |
| | 1583 | if (a[0].getTime() > b[0].getTime()) return 1; |
| | 1584 | return 0; |
| | 1585 | }); |
| | 1586 | |
| | 1587 | return sorted_holidays; |
| | 1588 | } |
| | 1589 | |
| | 1590 | //====================================================================== |
| | 1591 | // Year range parser (2013,2016-2018,2020/2) |
| | 1592 | //====================================================================== |
| | 1593 | function parseYearRange(tokens, at) { |
| | 1594 | for (; at < tokens.length; at++) { |
| | 1595 | if (matchTokens(tokens, at, 'year')) { |
| | 1596 | var is_range = false, has_period = false; |
| | 1597 | if (matchTokens(tokens, at+1, '-', 'year', '/', 'number')) { |
| | 1598 | var is_range = true; |
| | 1599 | var has_period = true; |
| | 1600 | if (tokens[at+4][0] == 1) |
| | 1601 | parsing_warnings.push([nblock, at+1+3, 'Please don’t use year ranges with period equals one (see README)']); |
| | 1602 | } else { |
| | 1603 | var is_range = matchTokens(tokens, at+1, '-', 'year'); |
| | 1604 | var has_period = matchTokens(tokens, at+1, '/', 'number'); |
| | 1605 | } |
| | 1606 | |
| | 1607 | selectors.year.push(function(tokens, at, is_range, has_period) { return function(date) { |
| | 1608 | var ouryear = date.getFullYear(); |
| | 1609 | var year_from = tokens[at][0]; |
| | 1610 | var year_to = is_range ? tokens[at+2][0] : year_from; |
| | 1611 | |
| | 1612 | // handle reversed range |
| | 1613 | if (year_to < year_from) { |
| | 1614 | var tmp = year_to; |
| | 1615 | year_to = year_from; |
| | 1616 | year_from = tmp; |
| | 1617 | } |
| | 1618 | |
| | 1619 | if (ouryear < year_from ){ |
| | 1620 | return [false, new Date(year_from, 0, 1)]; |
| | 1621 | } else if (has_period) { |
| | 1622 | if (year_from <= ouryear) { |
| | 1623 | if (is_range) { |
| | 1624 | var period = tokens[at+4][0]; |
| | 1625 | |
| | 1626 | if (year_to < ouryear) |
| | 1627 | return [false]; |
| | 1628 | } else { |
| | 1629 | var period = tokens[at+2][0]; |
| | 1630 | } |
| | 1631 | if (period > 0) { |
| | 1632 | if ((ouryear - year_from) % period == 0) { |
| | 1633 | return [true, new Date(ouryear + 1, 0, 1)]; |
| | 1634 | } else { |
| | 1635 | return [false, new Date(ouryear + period - 1, 0, 1)]; |
| | 1636 | } |
| | 1637 | } |
| | 1638 | } |
| | 1639 | } else if (is_range) { |
| | 1640 | if (year_from <= ouryear && ouryear <= year_to) |
| | 1641 | return [true, new Date(year_to + 1, 0, 1)]; |
| | 1642 | } else if (ouryear == year_from) { |
| | 1643 | return [true]; |
| | 1644 | } |
| | 1645 | |
| | 1646 | return [false]; |
| | 1647 | |
| | 1648 | }}(tokens, at, is_range, has_period)); |
| | 1649 | |
| | 1650 | at += 1 + (is_range ? 2 : 0) + (has_period ? 2 : 0); |
| | 1651 | } else { |
| | 1652 | throw formatWarnErrorMessage(nblock, at, 'Unexpected token in year range: ' + tokens[at][1]); |
| | 1653 | } |
| | 1654 | |
| | 1655 | if (!matchTokens(tokens, at, ',')) |
| | 1656 | break; |
| | 1657 | } |
| | 1658 | |
| | 1659 | return at; |
| | 1660 | } |
| | 1661 | |
| | 1662 | //====================================================================== |
| | 1663 | // Week range parser (week 11-20, week 1-53/2) |
| | 1664 | //====================================================================== |
| | 1665 | function parseWeekRange(tokens, at) { |
| | 1666 | for (; at < tokens.length; at++) { |
| | 1667 | if (matchTokens(tokens, at, 'number')) { |
| | 1668 | var is_range = matchTokens(tokens, at+1, '-', 'number'), has_period = false; |
| | 1669 | if (is_range) { |
| | 1670 | has_period = matchTokens(tokens, at+3, '/', 'number'); |
| | 1671 | // if (week_stable) { |
| | 1672 | // if (tokens[at][0] == 1 && tokens[at+2][0] >) // Maximum? |
| | 1673 | // week_stable = true; |
| | 1674 | // else |
| | 1675 | // week_stable = false; |
| | 1676 | // } else { |
| | 1677 | // week_stable = false; |
| | 1678 | // } |
| | 1679 | } |
| | 1680 | |
| | 1681 | selectors.week.push(function(tokens, at, is_range, has_period) { return function(date) { |
| | 1682 | var ourweek = Math.floor((date - dateAtWeek(date, 0)) / msec_in_week); |
| | 1683 | |
| | 1684 | var week_from = tokens[at][0] - 1; |
| | 1685 | var week_to = is_range ? tokens[at+2][0] - 1 : week_from; |
| | 1686 | |
| | 1687 | var start_of_next_year = new Date(date.getFullYear() + 1, 0, 1); |
| | 1688 | |
| | 1689 | // before range |
| | 1690 | if (ourweek < week_from) |
| | 1691 | return [false, getMinDate(dateAtWeek(date, week_from), start_of_next_year)]; |
| | 1692 | |
| | 1693 | // we're after range, set check date to next year |
| | 1694 | if (ourweek > week_to) |
| | 1695 | return [false, start_of_next_year]; |
| | 1696 | |
| | 1697 | // we're in range |
| | 1698 | var period; |
| | 1699 | if (has_period) { |
| | 1700 | var period = tokens[at+4][0]; |
| | 1701 | if (period > 1) { |
| | 1702 | var in_period = (ourweek - week_from) % period == 0; |
| | 1703 | if (in_period) |
| | 1704 | return [true, getMinDate(dateAtWeek(date, ourweek + 1), start_of_next_year)]; |
| | 1705 | else |
| | 1706 | return [false, getMinDate(dateAtWeek(date, ourweek + period - 1), start_of_next_year)]; |
| | 1707 | } |
| | 1708 | } |
| | 1709 | |
| | 1710 | return [true, getMinDate(dateAtWeek(date, week_to + 1), start_of_next_year)]; |
| | 1711 | }}(tokens, at, is_range, has_period)); |
| | 1712 | |
| | 1713 | at += 1 + (is_range ? 2 : 0) + (has_period ? 2 : 0); |
| | 1714 | } else { |
| | 1715 | throw formatWarnErrorMessage(nblock, at, 'Unexpected token in week range: ' + tokens[at][1]); |
| | 1716 | } |
| | 1717 | |
| | 1718 | if (!matchTokens(tokens, at, ',')) |
| | 1719 | break; |
| | 1720 | } |
| | 1721 | |
| | 1722 | return at; |
| | 1723 | } |
| | 1724 | |
| | 1725 | function dateAtWeek(date, week) { |
| | 1726 | var tmpdate = new Date(date.getFullYear(), 0, 1); |
| | 1727 | tmpdate.setDate(1 - (tmpdate.getDay() + 6) % 7 + week * 7); // start of week n where week starts on Monday |
| | 1728 | return tmpdate; |
| | 1729 | } |
| | 1730 | |
| | 1731 | function getMinDate(date /*, ...*/) { |
| | 1732 | for (var i = 1; i < arguments.length; i++) |
| | 1733 | if (arguments[i].getTime() < date.getTime()) |
| | 1734 | date = arguments[i]; |
| | 1735 | return date; |
| | 1736 | } |
| | 1737 | |
| | 1738 | //====================================================================== |
| | 1739 | // Month range parser (Jan,Feb-Mar) |
| | 1740 | //====================================================================== |
| | 1741 | function parseMonthRange(tokens, at) { |
| | 1742 | for (; at < tokens.length; at++) { |
| | 1743 | if (matchTokens(tokens, at, 'month')) { |
| | 1744 | // Single month (Jan) or month range (Feb-Mar) |
| | 1745 | var is_range = matchTokens(tokens, at+1, '-', 'month'); |
| | 1746 | |
| | 1747 | if (is_range && week_stable) { |
| | 1748 | var month_from = tokens[at][0]; |
| | 1749 | var month_to = tokens[at+2][0]; |
| | 1750 | if (month_from == (month_to + 1) % 12) |
| | 1751 | week_stable = true; |
| | 1752 | else |
| | 1753 | week_stable = false; |
| | 1754 | } else { |
| | 1755 | week_stable = false; |
| | 1756 | } |
| | 1757 | |
| | 1758 | selectors.month.push(function(tokens, at, is_range) { return function(date) { |
| | 1759 | var ourmonth = date.getMonth(); |
| | 1760 | var month_from = tokens[at][0]; |
| | 1761 | var month_to = is_range ? tokens[at+2][0] : month_from; |
| | 1762 | |
| | 1763 | var inside = true; |
| | 1764 | |
| | 1765 | // handle reversed range |
| | 1766 | if (month_to < month_from) { |
| | 1767 | var tmp = month_to; |
| | 1768 | month_to = month_from - 1; |
| | 1769 | month_from = tmp + 1; |
| | 1770 | inside = false; |
| | 1771 | } |
| | 1772 | |
| | 1773 | // handle full range |
| | 1774 | if (month_to < month_from) |
| | 1775 | return [!inside]; |
| | 1776 | |
| | 1777 | if (ourmonth < month_from || ourmonth > month_to) { |
| | 1778 | return [!inside, dateAtNextMonth(date, month_from)]; |
| | 1779 | } else { |
| | 1780 | return [inside, dateAtNextMonth(date, month_to + 1)]; |
| | 1781 | } |
| | 1782 | }}(tokens, at, is_range)); |
| | 1783 | |
| | 1784 | at += is_range ? 3 : 1; |
| | 1785 | } else { |
| | 1786 | throw formatWarnErrorMessage(nblock, at, 'Unexpected token in month range: ' + tokens[at][1]); |
| | 1787 | } |
| | 1788 | |
| | 1789 | if (!matchTokens(tokens, at, ',')) |
| | 1790 | break; |
| | 1791 | } |
| | 1792 | |
| | 1793 | return at; |
| | 1794 | } |
| | 1795 | |
| | 1796 | function dateAtNextMonth(date, month) { |
| | 1797 | return new Date(date.getFullYear(), month < date.getMonth() ? month + 12 : month); |
| | 1798 | } |
| | 1799 | |
| | 1800 | //====================================================================== |
| | 1801 | // Month day range parser (Jan 26-31; Jan 26-Feb 26) |
| | 1802 | //====================================================================== |
| | 1803 | function parseMonthdayRange(tokens, at) { |
| | 1804 | for (; at < tokens.length; at++) { |
| | 1805 | var has_year = [], has_month = [], has_event = [], has_calc = []; |
| | 1806 | has_year[0] = matchTokens(tokens, at, 'year'); |
| | 1807 | has_month[0] = matchTokens(tokens, at+has_year[0], 'month', 'number'); |
| | 1808 | has_event[0] = matchTokens(tokens, at+has_year[0], 'event'); |
| | 1809 | if (has_event[0]) |
| | 1810 | has_calc[0] = getMoveDays(tokens, at+has_year[0]+1, 200, 'event like easter'); |
| | 1811 | var at_range_sep = at+has_year[0] |
| | 1812 | + (has_event[0] |
| | 1813 | ? (typeof has_calc[0] != 'undefined' && has_calc[0][1] ? 4 : 1) |
| | 1814 | : 2); |
| | 1815 | if ((has_month[0] || has_event[0]) && matchTokens(tokens, at_range_sep, '-')) { |
| | 1816 | has_year[1] = matchTokens(tokens, at_range_sep+1, 'year'); |
| | 1817 | var at_sec_event_or_month = at_range_sep+1+has_year[1]; |
| | 1818 | has_month[1] = matchTokens(tokens, at_sec_event_or_month, 'month', 'number'); |
| | 1819 | if (!has_month[1]) { |
| | 1820 | has_event[1] = matchTokens(tokens, at_sec_event_or_month, 'event'); |
| | 1821 | if (has_event[1]) |
| | 1822 | has_calc[1] = getMoveDays(tokens, at_sec_event_or_month+1, 366, 'event like easter'); |
| | 1823 | } |
| | 1824 | } |
| | 1825 | |
| | 1826 | if (has_year[0] == has_year[1] && (has_month[1] || has_event[1])) { |
| | 1827 | |
| | 1828 | selectors.monthday.push(function(tokens, at, nblock, has_year, has_event, has_calc, at_sec_event_or_month) { return function(date) { |
| | 1829 | var start_of_next_year = new Date(date.getFullYear() + 1, 0, 1); |
| | 1830 | |
| | 1831 | if (has_event[0]) { |
| | 1832 | var movableDays = getMovableEventsForYear(has_year[0] ? parseInt(tokens[at][0]) : date.getFullYear()); |
| | 1833 | var from_date = movableDays[tokens[at+has_year[0]][0]]; |
| | 1834 | |
| | 1835 | if (typeof has_calc[0] != 'undefined' && has_calc[0][1]) { |
| | 1836 | var from_year_before_calc = from_date.getFullYear(); |
| | 1837 | from_date.setDate(from_date.getDate() + has_calc[0][0]); |
| | 1838 | if (from_year_before_calc != from_date.getFullYear()) |
| | 1839 | throw formatWarnErrorMessage(nblock, at+has_year[0]+has_calc[0][1]*3, |
| | 1840 | 'The movable day ' + tokens[at+has_year[0]][0] + ' plus ' + has_calc[0][0] |
| | 1841 | + ' days is not in the year of the movable day anymore. Currently not supported.'); |
| | 1842 | } |
| | 1843 | } else { |
| | 1844 | var from_date = new Date((has_year[0] ? tokens[at][0] : date.getFullYear()), |
| | 1845 | tokens[at+has_year[0]][0], tokens[at+has_year[0]+1][0]); |
| | 1846 | } |
| | 1847 | |
| | 1848 | if (has_event[1]) { |
| | 1849 | var movableDays = getMovableEventsForYear(has_year[1] |
| | 1850 | ? parseInt(tokens[at_sec_event_or_month-1][0]) |
| | 1851 | : date.getFullYear()); |
| | 1852 | var to_date = movableDays[tokens[at_sec_event_or_month][0]]; |
| | 1853 | |
| | 1854 | if (typeof has_calc[1] != 'undefined' && has_calc[1][1]) { |
| | 1855 | var to_year_before_calc = to_date.getFullYear(); |
| | 1856 | to_date.setDate(to_date.getDate() + has_calc[1][0]); |
| | 1857 | if (to_year_before_calc != to_date.getFullYear()) |
| | 1858 | throw formatWarnErrorMessage(nblock, at_sec_event_or_month+has_calc[1][1]*3, |
| | 1859 | 'The movable day ' + tokens[at_sec_event_or_month][0] + ' plus ' + has_calc[1][0] |
| | 1860 | + ' days is not in the year of the movable day anymore. Currently not supported.'); |
| | 1861 | } |
| | 1862 | } else { |
| | 1863 | var to_date = new Date((has_year[1] ? tokens[at_sec_event_or_month-1][0] : date.getFullYear()), |
| | 1864 | tokens[at_sec_event_or_month][0], tokens[at_sec_event_or_month+1][0] + 1); |
| | 1865 | } |
| | 1866 | |
| | 1867 | var inside = true; |
| | 1868 | |
| | 1869 | if (to_date < from_date) { |
| | 1870 | var tmp = to_date; |
| | 1871 | to_date = from_date; |
| | 1872 | from_date = tmp; |
| | 1873 | inside = false; |
| | 1874 | } |
| | 1875 | |
| | 1876 | if (date.getTime() < from_date.getTime()) { |
| | 1877 | return [!inside, from_date]; |
| | 1878 | } else if (date.getTime() < to_date.getTime()) { |
| | 1879 | return [inside, to_date]; |
| | 1880 | } else { |
| | 1881 | if (has_year[0]) |
| | 1882 | return [!inside]; |
| | 1883 | else |
| | 1884 | return [!inside, start_of_next_year]; |
| | 1885 | } |
| | 1886 | }}(tokens, at, nblock, has_year, has_event, has_calc, at_sec_event_or_month)); |
| | 1887 | |
| | 1888 | at = at_sec_event_or_month |
| | 1889 | + (has_event[1] |
| | 1890 | ? (typeof has_calc[1] != 'undefined' && has_calc[1][1] ? 4 : 1) |
| | 1891 | : 2); |
| | 1892 | |
| | 1893 | } else if (has_month[0]) { |
| | 1894 | var is_range = matchTokens(tokens, at+2+has_year[0], '-', 'number'), has_period = false; |
| | 1895 | if (is_range) |
| | 1896 | has_period = matchTokens(tokens, at+4+has_year[0], '/', 'number'); |
| | 1897 | |
| | 1898 | var at_timesep_if_monthRange = at + has_year[0] + 1 // at month number |
| | 1899 | + (is_range ? 2 : 0) + (has_period ? 2 : 0) |
| | 1900 | + !(is_range || has_period); // if not range nor has_period, add one |
| | 1901 | |
| | 1902 | if (matchTokens(tokens, at_timesep_if_monthRange, 'timesep')) |
| | 1903 | return parseMonthRange(tokens, at); |
| | 1904 | |
| | 1905 | selectors.monthday.push(function(tokens, at, is_range, has_period, has_year) { return function(date) { |
| | 1906 | var start_of_next_year = new Date(date.getFullYear() + 1, 0, 1); |
| | 1907 | |
| | 1908 | var from_date = new Date((has_year ? tokens[at][0] : date.getFullYear()), |
| | 1909 | tokens[at+has_year][0], tokens[at+1 + has_year][0]); |
| | 1910 | var to_date = new Date(from_date.getFullYear(), from_date.getMonth(), |
| | 1911 | tokens[at+(is_range ? 3 : 1)+has_year][0] + 1); |
| | 1912 | |
| | 1913 | if (date.getTime() < from_date.getTime()) |
| | 1914 | return [false, from_date]; |
| | 1915 | else if (date.getTime() >= to_date.getTime()) |
| | 1916 | return [false, start_of_next_year]; |
| | 1917 | else if (!has_period) |
| | 1918 | return [true, to_date]; |
| | 1919 | |
| | 1920 | var period = tokens[at+5][0]; |
| | 1921 | var nday = Math.floor((date.getTime() - from_date.getTime()) / msec_in_day); |
| | 1922 | var in_period = nday % period; |
| | 1923 | |
| | 1924 | if (in_period == 0) |
| | 1925 | return [true, new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1)]; |
| | 1926 | else |
| | 1927 | return [false, new Date(date.getFullYear(), date.getMonth(), date.getDate() + period - in_period)]; |
| | 1928 | }}(tokens, at, is_range, has_period, has_year[0])); |
| | 1929 | |
| | 1930 | at += 2 + has_year[0] + (is_range ? 2 : 0) + (has_period ? 2 : 0); |
| | 1931 | |
| | 1932 | } else if (has_event[0]) { |
| | 1933 | |
| | 1934 | selectors.monthday.push(function(tokens, at, nblock, has_event, has_year, add_days) { return function(date) { |
| | 1935 | |
| | 1936 | // console.log('enter selector with date: ' + date); |
| | 1937 | var movableDays = getMovableEventsForYear((has_year ? tokens[at][0] : date.getFullYear())); |
| | 1938 | var event_date = movableDays[tokens[at+has_year][0]]; |
| | 1939 | if (!event_date) |
| | 1940 | throw 'Movable day ' + tokens[at+has_year][0] + ' can not not be calculated.' |
| | 1941 | + ' Please add the formula how to calculate it.'; |
| | 1942 | |
| | 1943 | if (add_days[1]) { |
| | 1944 | event_date.setDate(event_date.getDate() + add_days[0]); |
| | 1945 | if (date.getFullYear() != event_date.getFullYear()) |
| | 1946 | throw formatWarnErrorMessage(nblock, at+has_year+add_days[1]*3, 'The movable day ' + tokens[at+has_year][0] + ' plus ' |
| | 1947 | + add_days[0] |
| | 1948 | + ' days is not in the year of the movable day anymore. Currently not supported.'); |
| | 1949 | } |
| | 1950 | |
| | 1951 | if (date.getTime() < event_date.getTime()) |
| | 1952 | return [false, event_date]; |
| | 1953 | // else if (date.getTime() < event_date.getTime() + msec_in_day) // does not work because of daylight saving times |
| | 1954 | else if (event_date.getMonth() * 100 + event_date.getDate() == date.getMonth() * 100 + date.getDate()) |
| | 1955 | return [true, new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1)]; |
| | 1956 | else |
| | 1957 | return [false, new Date(date.getFullYear() + 1, 0, 1)]; |
| | 1958 | |
| | 1959 | }}(tokens, at, nblock, has_event[0], has_year[0], has_calc[0])); |
| | 1960 | |
| | 1961 | at += has_year[0] + has_event[0] + (typeof has_calc[0][1] != 'undefined' && has_calc[0][1] ? 3 : 0); |
| | 1962 | } else { |
| | 1963 | // throw 'Unexpected token in monthday range: "' + tokens[at] + '"'; |
| | 1964 | return at; |
| | 1965 | } |
| | 1966 | |
| | 1967 | if (!matchTokens(tokens, at, ',')) |
| | 1968 | break; |
| | 1969 | } |
| | 1970 | |
| | 1971 | return at; |
| | 1972 | } |
| | 1973 | |
| | 1974 | //====================================================================== |
| | 1975 | // Main selector traversal function |
| | 1976 | //====================================================================== |
| | 1977 | this.getStatePair = function(date) { |
| | 1978 | var resultstate = false; |
| | 1979 | var changedate; |
| | 1980 | var unknown = false; |
| | 1981 | var comment = undefined; |
| | 1982 | var match_block; |
| | 1983 | |
| | 1984 | var date_matching_blocks = []; |
| | 1985 | |
| | 1986 | for (var nblock = 0; nblock < blocks.length; nblock++) { |
| | 1987 | var matching_date_block = true; |
| | 1988 | // console.log(nblock, 'length', blocks[nblock].date.length); |
| | 1989 | |
| | 1990 | // Try each date selector type |
| | 1991 | for (var ndateselector = 0; ndateselector < blocks[nblock].date.length; ndateselector++) { |
| | 1992 | var dateselectors = blocks[nblock].date[ndateselector]; |
| | 1993 | // console.log(nblock, ndateselector); |
| | 1994 | |
| | 1995 | var has_matching_selector = false; |
| | 1996 | for (var datesel = 0; datesel < dateselectors.length; datesel++) { |
| | 1997 | var res = dateselectors[datesel](date); |
| | 1998 | if (res[0]) { |
| | 1999 | has_matching_selector = true; |
| | 2000 | |
| | 2001 | if (typeof res[2] == 'string') { // holiday name |
| | 2002 | comment = [ res[2] ]; |
| | 2003 | } |
| | 2004 | |
| | 2005 | } |
| | 2006 | if (typeof changedate === 'undefined' || (typeof res[1] !== 'undefined' && res[1].getTime() < changedate.getTime())) |
| | 2007 | changedate = res[1]; |
| | 2008 | } |
| | 2009 | |
| | 2010 | if (!has_matching_selector) { |
| | 2011 | matching_date_block = false; |
| | 2012 | // We can ignore other date selectors, as the state won't change |
| | 2013 | // anyway until THIS selector matches (due to conjunction of date |
| | 2014 | // selectors of different types). |
| | 2015 | // This is also an optimization, if widest date selector types |
| | 2016 | // are checked first. |
| | 2017 | break; |
| | 2018 | } |
| | 2019 | |
| | 2020 | } |
| | 2021 | |
| | 2022 | if (matching_date_block) { |
| | 2023 | // The following lines implement date overwriting logic (e.g. for |
| | 2024 | // "Mo-Fr 10:00-20:00; We 10:00-16:00", We block overrides Mo-Fr block. |
| | 2025 | // |
| | 2026 | // This is the only way to be consistent. I thought about ("22:00-02:00; Tu 12:00-14:00") letting Th override 22:00-02:00 partly: |
| | 2027 | // Like: Th 00:00-02:00,12:00-14:00 but this would result in including 22:00-00:00 for Th which is probably not what you want. |
| | 2028 | if (blocks[nblock].date.length > 0 && (blocks[nblock].meaning || blocks[nblock].unknown) |
| | 2029 | && !blocks[nblock].wrapped && !blocks[nblock].additional && !blocks[nblock].fallback) { |
| | 2030 | // var old_date_matching_blocks = date_matching_blocks; |
| | 2031 | date_matching_blocks = []; |
| | 2032 | // for (var nblock = 0; nblock < old_date_matching_blocks.length; nblock++) { |
| | 2033 | // if (!blocks[old_date_matching_blocks[nblock]].wrapped) |
| | 2034 | // date_matching_blocks.push(nblock); |
| | 2035 | // } |
| | 2036 | } |
| | 2037 | date_matching_blocks.push(nblock); |
| | 2038 | } |
| | 2039 | } |
| | 2040 | |
| | 2041 | block: |
| | 2042 | for (var nblock = 0; nblock < date_matching_blocks.length; nblock++) { |
| | 2043 | var block = date_matching_blocks[nblock]; |
| | 2044 | |
| | 2045 | // console.log('Processing block ' + block + ':\t' + blocks[block].comment + ' with date', date, |
| | 2046 | // 'and', blocks[block].time.length, 'time selectors'); |
| | 2047 | |
| | 2048 | // there is no time specified, state applies to the whole day |
| | 2049 | if (blocks[block].time.length == 0) { |
| | 2050 | // console.log('there is no time', date); |
| | 2051 | if (!blocks[block].fallback || (blocks[block].fallback && !(resultstate || unknown))) { |
| | 2052 | resultstate = blocks[block].meaning; |
| | 2053 | unknown = blocks[block].unknown; |
| | 2054 | match_block = block; |
| | 2055 | |
| | 2056 | if (typeof blocks[block].comment != 'undefined') |
| | 2057 | comment = blocks[block].comment; |
| | 2058 | else if (typeof comment == 'object') // holiday name |
| | 2059 | comment = comment[0]; |
| | 2060 | |
| | 2061 | if (blocks[block].fallback) |
| | 2062 | break block; // fallback block matched, no need for checking the rest |
| | 2063 | } |
| | 2064 | } |
| | 2065 | |
| | 2066 | for (var timesel = 0; timesel < blocks[block].time.length; timesel++) { |
| | 2067 | var res = blocks[block].time[timesel](date); |
| | 2068 | |
| | 2069 | // console.log('res:', res); |
| | 2070 | if (res[0]) { |
| | 2071 | if (!blocks[block].fallback || (blocks[block].fallback && !(resultstate || unknown))) { |
| | 2072 | resultstate = blocks[block].meaning; |
| | 2073 | unknown = blocks[block].unknown; |
| | 2074 | match_block = block; |
| | 2075 | |
| | 2076 | if (typeof blocks[block].comment != 'undefined') // only use comment if one is specified |
| | 2077 | comment = blocks[block].comment; |
| | 2078 | else if (typeof comment == 'object') // holiday name |
| | 2079 | comment = comment[0]; |
| | 2080 | else if (comment === 'Specified as open end. Closing time was guessed.') |
| | 2081 | comment = blocks[block].comment; |
| | 2082 | |
| | 2083 | // open end |
| | 2084 | if (typeof res[2] == 'boolean' && res[2] && (resultstate || unknown)) { |
| | 2085 | if (typeof comment == 'undefined') |
| | 2086 | comment = 'Specified as open end. Closing time was guessed.'; |
| | 2087 | resultstate = false; |
| | 2088 | unknown = true; |
| | 2089 | } |
| | 2090 | |
| | 2091 | if (blocks[block].fallback) { |
| | 2092 | if (typeof changedate === 'undefined' || (typeof res[1] !== 'undefined' && res[1] < changedate)) |
| | 2093 | changedate = res[1]; |
| | 2094 | |
| | 2095 | break block; // fallback block matched, no need for checking the rest |
| | 2096 | } |
| | 2097 | } |
| | 2098 | } |
| | 2099 | if (typeof changedate === 'undefined' || (typeof res[1] !== 'undefined' && res[1] < changedate)) |
| | 2100 | changedate = res[1]; |
| | 2101 | } |
| | 2102 | } |
| | 2103 | |
| | 2104 | // console.log('changedate', changedate, resultstate, comment, match_block); |
| | 2105 | return [ resultstate, changedate, unknown, comment, match_block ]; |
| | 2106 | } |
| | 2107 | |
| | 2108 | function formatWarnErrorMessage(nblock, at, message) { |
| | 2109 | var pos = 0; |
| | 2110 | if (nblock == -1) { // usage of block index not required because we do have access to value.length |
| | 2111 | pos = value.length - at; |
| | 2112 | } else { // issue accrued at a later time |
| | 2113 | if (typeof tokens[nblock][0][at] == 'undefined') { |
| | 2114 | pos = value.length; |
| | 2115 | } else { |
| | 2116 | pos = value.length; |
| | 2117 | if (typeof tokens[nblock][0][at+1] != 'undefined') |
| | 2118 | pos -= tokens[nblock][0][at+1][2]; |
| | 2119 | else if (typeof tokens[nblock][2] != 'undefined') |
| | 2120 | pos -= tokens[nblock][2]; |
| | 2121 | } |
| | 2122 | } |
| | 2123 | return value.substring(0, pos) + ' <--- (' + message + ')'; |
| | 2124 | } |
| | 2125 | |
| | 2126 | function prettifySelector(tokens, at, last_at, conf, last_subparser) { |
| | 2127 | var value = ''; |
| | 2128 | var start_at = at; |
| | 2129 | while (at < last_at) { |
| | 2130 | if (matchTokens(tokens, at, 'weekday')) { |
| | 2131 | value += ['Su','Mo','Tu','We','Th','Fr','Sa'][tokens[at][0]]; |
| | 2132 | } else if (at - start_at > 0 && last_subparser == 'time' && matchTokens(tokens, at-1, 'timesep') |
| | 2133 | && matchTokens(tokens, at, 'number')) { |
| | 2134 | value += (tokens[at][0] < 10 ? '0' : '') + tokens[at][0].toString(); |
| | 2135 | } else if (last_subparser == 'time' && conf.leading_zero_hour && at != tokens.length |
| | 2136 | && matchTokens(tokens, at+1, 'timesep')) { |
| | 2137 | value += (tokens[at][0] < 10 ? (tokens[at][0] == 0 && conf.one_zero_if_hour_zero ? '' : '0') : '') + tokens[at][0].toString(); |
| | 2138 | } else if (matchTokens(tokens, at, 'weekday')) { |
| | 2139 | value += ['Su','Mo','Tu','We','Th','Fr','Sa'][tokens[at][0]]; |
| | 2140 | } else if (matchTokens(tokens, at, 'comment')) { |
| | 2141 | value += '"' + tokens[at][0].toString() + '"'; |
| | 2142 | } else if (matchTokens(tokens, at, 'closed')) { |
| | 2143 | value += (conf.leave_off_closed ? tokens[at][0] : conf.keyword_for_off_closed); |
| | 2144 | } else if (at - start_at > 0 && matchTokens(tokens, at, 'number') |
| | 2145 | && (matchTokens(tokens, at-1, 'month') |
| | 2146 | || matchTokens(tokens, at-1, 'week') |
| | 2147 | )) { |
| | 2148 | value += ' ' + tokens[at][0]; |
| | 2149 | } else if (at - start_at > 0 && matchTokens(tokens, at, 'month') |
| | 2150 | && matchTokens(tokens, at-1, 'year')) { |
| | 2151 | value += ' ' + months[[tokens[at][0]]]; |
| | 2152 | } else if (at - start_at > 0 && matchTokens(tokens, at, 'event') |
| | 2153 | && matchTokens(tokens, at-1, 'year')) { |
| | 2154 | value += ' ' + tokens[at][0]; |
| | 2155 | } else if (matchTokens(tokens, at, 'month')) { |
| | 2156 | value += months[[tokens[at][0]]]; |
| | 2157 | } else if (at + 2 < last_at |
| | 2158 | && (matchTokens(tokens, at, '-') || matchTokens(tokens, at, '+')) |
| | 2159 | && matchTokens(tokens, at+1, 'number', 'calcday')) { |
| | 2160 | value += ' ' + tokens[at][0] + tokens[at+1][0] + ' day' + (Math.abs(tokens[at+1][0]) == 1 ? '' : 's'); |
| | 2161 | at += 2; |
| | 2162 | } else { |
| | 2163 | // if (matchTokens(tokens, at, 'open') || matchTokens(tokens, at, 'unknown')) |
| | 2164 | // value += ' '; |
| | 2165 | |
| | 2166 | value += tokens[at][0].toString(); |
| | 2167 | } |
| | 2168 | at++; |
| | 2169 | } |
| | 2170 | return value + ' '; |
| | 2171 | } |
| | 2172 | |
| | 2173 | //====================================================================== |
| | 2174 | // Public interface |
| | 2175 | // All functions below are considered public. |
| | 2176 | //====================================================================== |
| | 2177 | |
| | 2178 | //====================================================================== |
| | 2179 | // Iterator interface |
| | 2180 | //====================================================================== |
| | 2181 | this.getIterator = function(date) { |
| | 2182 | return new function(oh) { |
| | 2183 | if (typeof date === 'undefined') |
| | 2184 | date = new Date(); |
| | 2185 | |
| | 2186 | var prevstate = [ undefined, date, undefined, undefined, undefined ]; |
| | 2187 | var state = oh.getStatePair(date); |
| | 2188 | |
| | 2189 | this.setDate = function(date) { |
| | 2190 | if (typeof date != 'object') |
| | 2191 | throw 'Date as parameter needed.'; |
| | 2192 | |
| | 2193 | prevstate = [ undefined, date, undefined, undefined, undefined ]; |
| | 2194 | state = oh.getStatePair(date); |
| | 2195 | } |
| | 2196 | |
| | 2197 | this.getDate = function() { |
| | 2198 | return prevstate[1]; |
| | 2199 | } |
| | 2200 | |
| | 2201 | this.getState = function() { |
| | 2202 | return state[0]; |
| | 2203 | } |
| | 2204 | |
| | 2205 | this.getUnknown = function() { |
| | 2206 | return state[2]; |
| | 2207 | } |
| | 2208 | |
| | 2209 | this.getStateString = function(past) { |
| | 2210 | return (state[0] ? 'open' : (state[2] ? 'unknown' : (past ? 'closed' : 'close'))); |
| | 2211 | } |
| | 2212 | |
| | 2213 | this.getComment = function() { |
| | 2214 | return state[3]; |
| | 2215 | } |
| | 2216 | |
| | 2217 | this.getMatchingRule = function(user_conf) { |
| | 2218 | if (typeof state[4] == 'undefined') |
| | 2219 | return undefined; |
| | 2220 | |
| | 2221 | if (typeof user_conf != 'object') |
| | 2222 | var user_conf = {}; |
| | 2223 | for (key in default_prettify_conf) { |
| | 2224 | if (typeof user_conf[key] != 'undefined') |
| | 2225 | user_conf[key] = default_prettify_conf[key]; |
| | 2226 | } |
| | 2227 | |
| | 2228 | prettified_value = ''; |
| | 2229 | var selectors = { // Not really needed. This whole thing is only necessary because of the token used for additional blocks. |
| | 2230 | time: [], weekday: [], holiday: [], week: [], month: [], monthday: [], year: [], wraptime: [], |
| | 2231 | |
| | 2232 | fallback: false, // does not matter |
| | 2233 | additional: false, |
| | 2234 | meaning: true, |
| | 2235 | unknown: false, |
| | 2236 | comment: undefined, |
| | 2237 | }; |
| | 2238 | |
| | 2239 | parseGroup(tokens[state[4]][0], 0, selectors, user_conf); |
| | 2240 | |
| | 2241 | return prettified_value; |
| | 2242 | } |
| | 2243 | |
| | 2244 | this.advance = function(datelimit) { |
| | 2245 | if (typeof datelimit === 'undefined') |
| | 2246 | datelimit = new Date(prevstate[1].getTime() + msec_in_day * 366 * 5); |
| | 2247 | else if (datelimit.getTime() <= prevstate[1].getTime()) |
| | 2248 | return false; // The limit for advance needs to be after the current time. |
| | 2249 | |
| | 2250 | do { |
| | 2251 | // open range, we won't be able to advance |
| | 2252 | if (typeof state[1] === 'undefined') |
| | 2253 | return false; |
| | 2254 | |
| | 2255 | // console.log('\n' + 'previous check time:', prevstate[1] |
| | 2256 | // + ', current check time:', |
| | 2257 | // // (state[1].getHours() < 10 ? '0' : '') + state[1].getHours() + |
| | 2258 | // // ':'+(state[1].getMinutes() < 10 ? '0' : '')+ state[1].getMinutes(), state[1].getDate(), |
| | 2259 | // state[1], |
| | 2260 | // (state[0] ? 'open' : (state[2] ? 'unknown' : 'closed')) + ', comment:', state[3]); |
| | 2261 | |
| | 2262 | // We're going backwards or staying at place. |
| | 2263 | // This always indicates coding error in a selector code. |
| | 2264 | if (state[1].getTime() <= prevstate[1].getTime()) |
| | 2265 | throw 'Fatal: infinite loop in nextChange'; |
| | 2266 | |
| | 2267 | // don't advance beyond limits (same as open range) |
| | 2268 | if (state[1].getTime() >= datelimit.getTime()) |
| | 2269 | return false; |
| | 2270 | |
| | 2271 | // do advance |
| | 2272 | prevstate = state; |
| | 2273 | state = oh.getStatePair(prevstate[1]); |
| | 2274 | } while (state[0] === prevstate[0] && state[2] === prevstate[2] && state[3] === prevstate[3]); |
| | 2275 | return true; |
| | 2276 | } |
| | 2277 | }(this); |
| | 2278 | } |
| | 2279 | |
| | 2280 | // get parse warnings |
| | 2281 | // returns an empty string if there are no warnings |
| | 2282 | this.getWarnings = function() { |
| | 2283 | var it = this.getIterator(); |
| | 2284 | return getWarnings(it).join('\n');; |
| | 2285 | } |
| | 2286 | |
| | 2287 | // get a nicely formated value. |
| | 2288 | this.prettifyValue = function(user_conf) { |
| | 2289 | if (typeof user_conf != 'object') |
| | 2290 | var user_conf = {}; |
| | 2291 | |
| | 2292 | for (key in default_prettify_conf) { |
| | 2293 | if (typeof user_conf[key] == 'undefined') |
| | 2294 | user_conf[key] = default_prettify_conf[key]; |
| | 2295 | } |
| | 2296 | |
| | 2297 | prettified_value = ''; |
| | 2298 | for (var nblock = 0; nblock < tokens.length; nblock++) { |
| | 2299 | if (tokens[nblock][0].length == 0) continue; |
| | 2300 | // Block does contain nothing useful e.g. second block of '10:00-12:00;' (empty) which needs to be handled. |
| | 2301 | |
| | 2302 | if (nblock != 0) |
| | 2303 | prettified_value += (tokens[nblock][1] |
| | 2304 | ? user_conf.block_sep_string + '|| ' |
| | 2305 | : (user_conf.print_semicolon ? ';' : '') + user_conf.block_sep_string); |
| | 2306 | |
| | 2307 | var continue_at = 0; |
| | 2308 | do { |
| | 2309 | if (continue_at == tokens[nblock][0].length) break; |
| | 2310 | // Block does contain nothing useful e.g. second block of '10:00-12:00,' (empty) which needs to be handled. |
| | 2311 | |
| | 2312 | var selectors = { // Not really needed. This whole thing is only necessary because of the token used for additional blocks. |
| | 2313 | time: [], weekday: [], holiday: [], week: [], month: [], monthday: [], year: [], wraptime: [], |
| | 2314 | |
| | 2315 | fallback: tokens[nblock][1], |
| | 2316 | additional: continue_at ? true : false, |
| | 2317 | meaning: true, |
| | 2318 | unknown: false, |
| | 2319 | comment: undefined, |
| | 2320 | }; |
| | 2321 | |
| | 2322 | continue_at = parseGroup(tokens[nblock][0], continue_at, selectors, user_conf); |
| | 2323 | |
| | 2324 | if (typeof continue_at == 'object') { |
| | 2325 | continue_at = continue_at[0]; |
| | 2326 | prettified_value += user_conf.block_sep_string; |
| | 2327 | } else { |
| | 2328 | continue_at = 0; |
| | 2329 | } |
| | 2330 | |
| | 2331 | } while (continue_at) |
| | 2332 | } |
| | 2333 | |
| | 2334 | return prettified_value; |
| | 2335 | } |
| | 2336 | |
| | 2337 | // check whether facility is `open' on the given date (or now) |
| | 2338 | this.getState = function(date) { |
| | 2339 | var it = this.getIterator(date); |
| | 2340 | return it.getState(); |
| | 2341 | } |
| | 2342 | |
| | 2343 | // If the state of a amenity is conditional. Conditions can be expressed in comments. |
| | 2344 | // True will only be returned if the state is false as the getState only |
| | 2345 | // returns true if the amenity is really open. So you may want to check |
| | 2346 | // the resold of getUnknown if getState returned false. |
| | 2347 | this.getUnknown = function(date) { |
| | 2348 | var it = this.getIterator(date); |
| | 2349 | return it.getUnknown(); |
| | 2350 | } |
| | 2351 | |
| | 2352 | // Return state string. Either 'open', 'unknown' or 'closed'. |
| | 2353 | this.getStateString = function(date, past) { |
| | 2354 | var it = this.getIterator(date); |
| | 2355 | return it.getStateString(past); |
| | 2356 | } |
| | 2357 | |
| | 2358 | // Returns the comment. |
| | 2359 | // Most often this will be an empty string as comments are not used that |
| | 2360 | // often in OSM yet. |
| | 2361 | this.getComment = function(date) { |
| | 2362 | var it = this.getIterator(date); |
| | 2363 | return it.getComment(); |
| | 2364 | } |
| | 2365 | |
| | 2366 | this.getMatchingRule = function(date) { |
| | 2367 | var it = this.getIterator(date); |
| | 2368 | return it.getMatchingRule(); |
| | 2369 | } |
| | 2370 | |
| | 2371 | // returns time of next status change |
| | 2372 | this.getNextChange = function(date, maxdate) { |
| | 2373 | var it = this.getIterator(date); |
| | 2374 | if (!it.advance(maxdate)) |
| | 2375 | return undefined; |
| | 2376 | return it.getDate(); |
| | 2377 | } |
| | 2378 | |
| | 2379 | // return array of open intervals between two dates |
| | 2380 | this.getOpenIntervals = function(from, to) { |
| | 2381 | var res = []; |
| | 2382 | |
| | 2383 | var it = this.getIterator(from); |
| | 2384 | |
| | 2385 | if (it.getState() || it.getUnknown()) |
| | 2386 | res.push([from, undefined, it.getUnknown(), it.getComment()]); |
| | 2387 | |
| | 2388 | while (it.advance(to)) { |
| | 2389 | if (it.getState() || it.getUnknown()) { |
| | 2390 | if (res.length != 0 && typeof res[res.length - 1][1] == 'undefined') { |
| | 2391 | // last state was also open or unknown |
| | 2392 | res[res.length - 1][1] = it.getDate(); |
| | 2393 | } |
| | 2394 | res.push([it.getDate(), undefined, it.getUnknown(), it.getComment()]); |
| | 2395 | } else { |
| | 2396 | if (res.length != 0 && typeof res[res.length - 1][1] == 'undefined') { |
| | 2397 | // only use the first time as closing/change time and ignore closing times which might follow |
| | 2398 | res[res.length - 1][1] = it.getDate(); |
| | 2399 | } |
| | 2400 | } |
| | 2401 | } |
| | 2402 | |
| | 2403 | if (res.length > 0 && typeof res[res.length - 1][1] === 'undefined') |
| | 2404 | res[res.length - 1][1] = to; |
| | 2405 | |
| | 2406 | return res; |
| | 2407 | } |
| | 2408 | |
| | 2409 | // return total number of milliseconds a facility is open within a given date range |
| | 2410 | this.getOpenDuration = function(from, to) { |
| | 2411 | // console.log('-----------'); |
| | 2412 | |
| | 2413 | var open = 0; |
| | 2414 | var unknown = 0; |
| | 2415 | |
| | 2416 | var it = this.getIterator(from); |
| | 2417 | var prevdate = (it.getState() || it.getUnknown()) ? from : undefined; |
| | 2418 | var prevstate = it.getState(); |
| | 2419 | var prevunknown = it.getUnknown(); |
| | 2420 | |
| | 2421 | while (it.advance(to)) { |
| | 2422 | if (it.getState() || it.getUnknown()) { |
| | 2423 | |
| | 2424 | if (typeof prevdate !== 'undefined') { |
| | 2425 | // last state was also open or unknown |
| | 2426 | if (prevunknown) // |
| | 2427 | unknown += it.getDate().getTime() - prevdate.getTime(); |
| | 2428 | else if (prevstate) |
| | 2429 | open += it.getDate().getTime() - prevdate.getTime(); |
| | 2430 | } |
| | 2431 | |
| | 2432 | prevdate = it.getDate(); |
| | 2433 | prevstate = it.getState(); |
| | 2434 | prevunknown = it.getUnknown(); |
| | 2435 | // console.log('if', prevdate, open / (1000 * 60 * 60), unknown / (1000 * 60 * 60)); |
| | 2436 | } else { |
| | 2437 | // console.log('else', prevdate); |
| | 2438 | if (typeof prevdate !== 'undefined') { |
| | 2439 | if (prevunknown) |
| | 2440 | unknown += it.getDate().getTime() - prevdate.getTime(); |
| | 2441 | else |
| | 2442 | open += it.getDate().getTime() - prevdate.getTime(); |
| | 2443 | prevdate = undefined; |
| | 2444 | } |
| | 2445 | } |
| | 2446 | } |
| | 2447 | |
| | 2448 | if (typeof prevdate !== 'undefined') { |
| | 2449 | if (prevunknown) |
| | 2450 | unknown += to.getTime() - prevdate.getTime(); |
| | 2451 | else |
| | 2452 | open += to.getTime() - prevdate.getTime(); |
| | 2453 | } |
| | 2454 | |
| | 2455 | return [ open, unknown ]; |
| | 2456 | } |
| | 2457 | |
| | 2458 | this.isWeekStable = function() { |
| | 2459 | return week_stable; |
| | 2460 | } |
| | 2461 | } |
| | 2462 | })); |
