9329031439

Committed 01 Jun 2024 08:48AM UTC coverage: 55.345% (+0.002%) from 55.343%

Build # 9329031439

Build Type

push

github

Committed by

rinick

Commit Message

fix dead loop with auto timezone

Run Details

4734 of 9968 branches covered (47.49%)

Branch coverage included in aggregate %.

5 of 21 new or added lines in 3 files covered. (23.81%)

1 existing line in 1 file now uncovered.

13319 of 22651 relevant lines covered (58.8%)

242.23 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/editor/scheduler/ScheduleLoader.tsx

import React, {CSSProperties} from 'react';
import {Event} from 'ticlo-big-calendar';
import {ClientConn, ValueSubscriber} from '../../core/connect/ClientConn';
import {ValueUpdate} from '../../core/connect/ClientRequests';
import {
  EventOccur,
  SchedulerConfig,
  SchedulerEvent,
  validateEventConfig,
} from '../../core/functions/date/Schedule/SchedulerEvent';
import {cacheCall} from '../util/CachedCallback';
import {deepEqual} from '../../core/util/Compare';
import {encodeDisplay} from '../../core';
import {stringify as stringifyYaml} from 'yaml';
import {verboseReplacer} from '../../core/util/Serialize';

const priorityStr = '⓿❶❷❸❹❺❻❼❽❾❿';

function getTitle(config: SchedulerConfig, value: unknown) {
  const parts: string[] = [];
  if (config?.name) {
    parts.push(config.name);
  }
  parts.push(stringifyYaml(value, verboseReplacer));
  return parts.join('\n');
}

export class CalendarEvent implements Event {
  readonly id: string;
  readonly start: Date;
  readonly end: Date;
  allDay?: boolean;
  icon?: React.ReactNode;
  constructor(
    start: number,
    end: number,
    public readonly title: string,
    public readonly parent: ConfigValuePair
  ) {
    this.start = new Date(start);
    this.end = new Date(end);
    this.id = `${parent.idx}-${this.start.getMonth()}-${this.start.getDate()}`;
    if (
      this.start.getHours() === 0 &&
      this.start.getMinutes() === 0 &&
      this.end.getHours() === 23 &&
      this.end.getMinutes() === 59
    ) {
      this.allDay = true;
    }
    const priority = parent?.event?.priority;
    if (Number.isFinite(priority)) {
      const n = Math.round(priority);
      if (n >= 0 && n <= 10) {
        this.icon = <span>{priorityStr.charAt(n)}</span>;
      } else {
        this.icon = <span>({n})</span>;
      }
    }
  }
}

class ConfigValuePair {
  configSub = new ValueSubscriber({
    onUpdate: (response: ValueUpdate) => {
      if (this.config !== response.cache.value) {
        this.config = response.cache.value;
        this.createEvent();
      }
    },
  });
  valueSub = new ValueSubscriber({
    onUpdate: (response: ValueUpdate) => {
      if (!deepEqual(response.cache.value, this.value)) {
        this.value = response.cache.value;
        this.buildStyle();
        this.parent.parent.forceUpdate();
      }
    },
  });
  constructor(
    public readonly idx: number,
    public readonly parent: ScheduleLoader
  ) {
    this.configSub.subscribe(parent.conn, `${parent.schedulePath}.config${idx}`, true);
    this.valueSub.subscribe(parent.conn, `${parent.schedulePath}.value${idx}`);
  }

  config: SchedulerConfig;
  event: SchedulerEvent;
  value: unknown;
  style?: CSSProperties = {borderLeftStyle: 'dotted'};
  visible = true;

  createEvent() {
    if (typeof this.config !== 'object' || Array.isArray(this.config)) {
      this.config = null;
    }
    const event = SchedulerEvent.fromProperty(this.config, this.parent.zone);
    if (event) {
      this.event = event;
      this.buildStyle();
    } else {
      this.event = null;
      this.buildStyle();
    }
    this.parent.parent.forceUpdate();
  }

  toggleVisible() {
    this.visible = !this.visible;
    this.parent.parent.forceUpdate();
  }
  buildStyle() {
    const style: CSSProperties = {};
    if (this.config?.color) {
      style.borderLeftColor = this.config.color;
    }
    if (!Boolean(this.value)) {
      style.borderLeftStyle = 'dotted';
    }
    this.style = style;
  }

  updateZone(zone: string) {
    this.createEvent();
  }

  #getCachedEvents = cacheCall(
    ([start, end, event, value]: [number, number, SchedulerEvent, unknown]) => {
      const result: CalendarEvent[] = [];
      if (event) {
        let next = start;
        while (next <= end) {
          let o = event.getOccur(next);
          if (o.isValid()) {
            // event will change everytime config changes, so the cache is valid.
            result.push(new CalendarEvent(o.start, o.end, getTitle(this.config, value), this));
            next = o.end + 1;
          } else {
            break;
          }
        }
      }
      return result;
    },
    null,
    []
  );

  getEvents(start: number, end: number): CalendarEvent[] {
    if (this.visible) {
      return this.#getCachedEvents([start, end, this.event, this.value]);
    }
    return [];
  }

  #getDummyEvent = cacheCall(([event, value]: [config: SchedulerEvent, unknown]) => {
    // event will change everytime config changes, so the cache is valid.
    return new CalendarEvent(1, 2, getTitle(this.config, value), this);
  });
  getDummyEvent(): CalendarEvent {
    return this.#getDummyEvent([this.event, this.value]);
  }

  destroy() {
    this.configSub.unsubscribe();
    this.valueSub.unsubscribe();
  }
}

export class ScheduleLoader {
  timezoneSub = new ValueSubscriber({
    onUpdate: (response: ValueUpdate) => {
      this.updateZone(response.cache.value);
    },
  });
  eventsLenSub = new ValueSubscriber({
    onUpdate: (response: ValueUpdate) => {
      this.updateEventLength(response.cache.value);
    },
  });
  constructor(
    public readonly parent: {forceUpdate: Function},
    public readonly conn: ClientConn,
    public readonly schedulePath: string
  ) {
    this.timezoneSub.subscribe(conn, `${schedulePath}.timezone`, true);
    this.eventsLenSub.subscribe(conn, `${schedulePath}.[]`, true);
  }
  subs: ConfigValuePair[] = [];

  zone: string = 'notReady';
  updateZone(z: string) {
    let zone = z;
    if (zone === 'auto') zone = 'Factory';
    if (this.zone !== zone) {
      this.zone = zone;
      for (let sub of this.subs) {
        sub.updateZone(zone);
      }
    }
  }
  length: number;
  updateEventLength(v: unknown) {
    let len = 1;
    if (Number.isInteger(v) && (v as number) > 1) {
      len = v as number;
    }
    if (this.length !== len) {
      this.length = len;
      this.createPairs();
    }
  }
  createPairs() {
    if (this.length == null || this.zone === 'notReady') {
      return;
    }
    const len = this.length;
    if (len !== this.subs.length) {
      if (len < this.subs.length) {
        for (let i = len; i < this.subs.length; i++) {
          this.subs[i].destroy();
        }
        this.subs.length = len;
      } else {
        while (len > this.subs.length) {
          this.subs.push(new ConfigValuePair(this.subs.length, this));
        }
      }
      this.parent.forceUpdate();
    }
  }
  getEvents(start: number, end: number) {
    const result: CalendarEvent[] = [];
    for (let pair of this.subs) {
      result.push(...pair.getEvents(start, end));
    }
    return result;
  }
  getDummyEvents() {
    const result: CalendarEvent[] = [];
    for (let pair of this.subs) {
      result.push(pair.getDummyEvent());
    }
    return result;
  }

  destroy(): void {
    this.timezoneSub.unsubscribe();
    this.eventsLenSub.unsubscribe();
    for (let sub of this.subs) {
      sub.destroy();
    }
  }
}

1	import React, {CSSProperties} from 'react';	×
2	import {Event} from 'ticlo-big-calendar';
3	import {ClientConn, ValueSubscriber} from '../../core/connect/ClientConn';
4	import {ValueUpdate} from '../../core/connect/ClientRequests';
5	import {
6	EventOccur,
7	SchedulerConfig,
8	SchedulerEvent,
9	validateEventConfig,
10	} from '../../core/functions/date/Schedule/SchedulerEvent';
11	import {cacheCall} from '../util/CachedCallback';
12	import {deepEqual} from '../../core/util/Compare';
13	import {encodeDisplay} from '../../core';
14	import {stringify as stringifyYaml} from 'yaml';
15	import {verboseReplacer} from '../../core/util/Serialize';
16
17	const priorityStr = '⓿❶❷❸❹❺❻❼❽❾❿';	×
18
19	function getTitle(config: SchedulerConfig, value: unknown) {
20	const parts: string[] = [];	×
21	if (config?.name) {	×
22	parts.push(config.name);	×
23	}
24	parts.push(stringifyYaml(value, verboseReplacer));	×
25	return parts.join('\n');	×
26	}
27
28	export class CalendarEvent implements Event {
29	readonly id: string;
30	readonly start: Date;
31	readonly end: Date;
32	allDay?: boolean;
33	icon?: React.ReactNode;
34	constructor(
35	start: number,
36	end: number,
37	public readonly title: string,	×
38	public readonly parent: ConfigValuePair	×
39	) {
40	this.start = new Date(start);	×
41	this.end = new Date(end);	×
42	this.id = `${parent.idx}-${this.start.getMonth()}-${this.start.getDate()}`;	×
43	if (	×
44	this.start.getHours() === 0 &&	×
45	this.start.getMinutes() === 0 &&
46	this.end.getHours() === 23 &&
47	this.end.getMinutes() === 59
48	) {
49	this.allDay = true;	×
50	}
51	const priority = parent?.event?.priority;	×
52	if (Number.isFinite(priority)) {	×
53	const n = Math.round(priority);	×
54	if (n >= 0 && n <= 10) {	×
55	this.icon = <span>{priorityStr.charAt(n)}</span>;	×
56	} else {
57	this.icon = <span>({n})</span>;	×
58	}
59	}
60	}
61	}
62
63	class ConfigValuePair {
64	configSub = new ValueSubscriber({	×
65	onUpdate: (response: ValueUpdate) => {
66	if (this.config !== response.cache.value) {	×
67	this.config = response.cache.value;	×
NEW 68	this.createEvent();	×
69	}
70	},
71	});
72	valueSub = new ValueSubscriber({	×
73	onUpdate: (response: ValueUpdate) => {
74	if (!deepEqual(response.cache.value, this.value)) {	×
75	this.value = response.cache.value;	×
76	this.buildStyle();	×
77	this.parent.parent.forceUpdate();	×
78	}
79	},
80	});
81	constructor(
82	public readonly idx: number,	×
83	public readonly parent: ScheduleLoader	×
84	) {
85	this.configSub.subscribe(parent.conn, `${parent.schedulePath}.config${idx}`, true);	×
86	this.valueSub.subscribe(parent.conn, `${parent.schedulePath}.value${idx}`);	×
87	}
88
89	config: SchedulerConfig;
90	event: SchedulerEvent;
91	value: unknown;
92	style?: CSSProperties = {borderLeftStyle: 'dotted'};	×
93	visible = true;	×
94
95	createEvent() {
NEW 96	if (typeof this.config !== 'object' \|\| Array.isArray(this.config)) {	×
NEW 97	this.config = null;	×
98	}
NEW 99	const event = SchedulerEvent.fromProperty(this.config, this.parent.zone);	×
NEW 100	if (event) {	×
NEW 101	this.event = event;	×
NEW 102	this.buildStyle();	×
103	} else {
NEW 104	this.event = null;	×
NEW 105	this.buildStyle();	×
106	}
NEW 107	this.parent.parent.forceUpdate();	×
108	}
109
110	toggleVisible() {
111	this.visible = !this.visible;	×
112	this.parent.parent.forceUpdate();	×
113	}
114	buildStyle() {
115	const style: CSSProperties = {};	×
116	if (this.config?.color) {	×
117	style.borderLeftColor = this.config.color;	×
118	}
119	if (!Boolean(this.value)) {	×
120	style.borderLeftStyle = 'dotted';	×
121	}
122	this.style = style;	×
123	}
124
125	updateZone(zone: string) {
NEW 126	this.createEvent();	×
127	}
128
UNCOV 129	#getCachedEvents = cacheCall(	×
130	([start, end, event, value]: [number, number, SchedulerEvent, unknown]) => {
131	const result: CalendarEvent[] = [];	×
132	if (event) {	×
133	let next = start;	×
134	while (next <= end) {	×
135	let o = event.getOccur(next);	×
136	if (o.isValid()) {	×
137	// event will change everytime config changes, so the cache is valid.
138	result.push(new CalendarEvent(o.start, o.end, getTitle(this.config, value), this));	×
139	next = o.end + 1;	×
140	} else {
141	break;	×
142	}
143	}
144	}
145	return result;	×
146	},
147	null,
148	[]
149	);
150
151	getEvents(start: number, end: number): CalendarEvent[] {
152	if (this.visible) {	×
153	return this.#getCachedEvents([start, end, this.event, this.value]);	×
154	}
155	return [];	×
156	}
157
158	#getDummyEvent = cacheCall(([event, value]: [config: SchedulerEvent, unknown]) => {	×
159	// event will change everytime config changes, so the cache is valid.
160	return new CalendarEvent(1, 2, getTitle(this.config, value), this);	×
161	});
162	getDummyEvent(): CalendarEvent {
163	return this.#getDummyEvent([this.event, this.value]);	×
164	}
165
166	destroy() {
167	this.configSub.unsubscribe();	×
168	this.valueSub.unsubscribe();	×
169	}
170	}
171
172	export class ScheduleLoader {
173	timezoneSub = new ValueSubscriber({	×
174	onUpdate: (response: ValueUpdate) => {
175	this.updateZone(response.cache.value);	×
176	},
177	});
178	eventsLenSub = new ValueSubscriber({	×
179	onUpdate: (response: ValueUpdate) => {
180	this.updateEventLength(response.cache.value);	×
181	},
182	});
183	constructor(
184	public readonly parent: {forceUpdate: Function},	×
185	public readonly conn: ClientConn,	×
186	public readonly schedulePath: string	×
187	) {
188	this.timezoneSub.subscribe(conn, `${schedulePath}.timezone`, true);	×
189	this.eventsLenSub.subscribe(conn, `${schedulePath}.[]`, true);	×
190	}
191	subs: ConfigValuePair[] = [];	×
192
193	zone: string = 'notReady';	×
194	updateZone(z: string) {
NEW 195	let zone = z;	×
NEW 196	if (zone === 'auto') zone = 'Factory';	×
197	if (this.zone !== zone) {	×
198	this.zone = zone;	×
199	for (let sub of this.subs) {	×
NEW 200	sub.updateZone(zone);	×
201	}
202	}
203	}
204	length: number;
205	updateEventLength(v: unknown) {
206	let len = 1;	×
207	if (Number.isInteger(v) && (v as number) > 1) {	×
208	len = v as number;	×
209	}
210	if (this.length !== len) {	×
211	this.length = len;	×
212	this.createPairs();	×
213	}
214	}
215	createPairs() {
216	if (this.length == null \|\| this.zone === 'notReady') {	×
217	return;	×
218	}
219	const len = this.length;	×
220	if (len !== this.subs.length) {	×
221	if (len < this.subs.length) {	×
222	for (let i = len; i < this.subs.length; i++) {	×
223	this.subs[i].destroy();	×
224	}
225	this.subs.length = len;	×
226	} else {
227	while (len > this.subs.length) {	×
228	this.subs.push(new ConfigValuePair(this.subs.length, this));	×
229	}
230	}
231	this.parent.forceUpdate();	×
232	}
233	}
234	getEvents(start: number, end: number) {
235	const result: CalendarEvent[] = [];	×
236	for (let pair of this.subs) {	×
237	result.push(...pair.getEvents(start, end));	×
238	}
239	return result;	×
240	}
241	getDummyEvents() {
242	const result: CalendarEvent[] = [];	×
243	for (let pair of this.subs) {	×
244	result.push(pair.getDummyEvent());	×
245	}
246	return result;	×
247	}
248
249	destroy(): void {
250	this.timezoneSub.unsubscribe();	×
251	this.eventsLenSub.unsubscribe();	×
252	for (let sub of this.subs) {	×
253	sub.destroy();	×
254	}
255	}
256	}

ticlo / ticlo / 9329031439

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous