occam-verify-cli 0.0.376 → 0.0.378

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. package/bin/main.js +2 -2
  2. package/bin/utilities/fileSystem.js +34 -11
  3. package/lib/context/file.js +23 -43
  4. package/lib/context/release/directory.js +60 -72
  5. package/lib/context/release/file.js +49 -55
  6. package/lib/utilities/releaseContext.js +3 -17
  7. package/package.json +1 -1
  8. package/src/context/file.js +27 -27
  9. package/src/context/release/directory.js +68 -92
  10. package/src/context/release/file.js +53 -71
  11. package/src/utilities/releaseContext.js +2 -28
package/src/context/release/directory.js CHANGED
@@ -16,138 +16,118 @@ export default class DirectoryReleaseContext extends ReleaseContext {
16
16
  return this.fileContexts;
17
17
  }
18
18
 
19
- getTypes(releaseNames = []) {
20
- const types = [],
21
- releaseName = this.getReleaseName(),
22
- releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
19
+ getLabels(includeDependencies = true) {
20
+ const labels = [];
23
21
 
24
- if (!releaseNamesIncludesReleaseName) {
25
- releaseNames.push(releaseName);
26
-
27
- const bubble = false;
28
-
29
- this.fileContexts.forEach((fileContext) => {
30
- const fileContextTypes = fileContext.getTypes(bubble);
22
+ this.fileContexts.forEach((fileContext) => {
23
+ const includeRelease = false,
24
+ fileContextLabels = fileContext.getLabels(includeRelease);
31
25
 
32
- push(types, fileContextTypes);
33
- });
26
+ push(labels, fileContextLabels);
27
+ });
34
28
 
29
+ if (includeDependencies) {
35
30
  const dependencyReleaseContexts = this.getDependencyReleaseContexts();
36
31
 
37
32
  dependencyReleaseContexts.forEach((releaseContext) => {
38
- const releaseContextTypes = releaseContext.getTypes(releaseNames);
33
+ const includeDependencies = false,
34
+ releaseContextLabels = releaseContext.getLabels(includeDependencies);
39
35
 
40
- push(types, releaseContextTypes);
36
+ push(labels, releaseContextLabels);
41
37
  });
42
38
  }
43
39
 
44
- return types;
40
+ return labels;
45
41
  }
46
42
 
47
- getRules(releaseNames = []) {
48
- const rules = [],
49
- releaseName = this.getReleaseName(),
50
- releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
43
+ getTypes(includeDependencies = true) {
44
+ const types = [];
51
45
 
52
- if (!releaseNamesIncludesReleaseName) {
53
- releaseNames.push(releaseName);
54
-
55
- const bubble = false;
56
-
57
- this.fileContexts.forEach((fileContext) => {
58
- const fileContextRules = fileContext.getRules(bubble);
46
+ this.fileContexts.forEach((fileContext) => {
47
+ const includeRelease = false,
48
+ fileContextTypes = fileContext.getTypes(includeRelease);
59
49
 
60
- push(rules, fileContextRules);
61
- });
50
+ push(types, fileContextTypes);
51
+ });
62
52
 
53
+ if (includeDependencies) {
63
54
  const dependencyReleaseContexts = this.getDependencyReleaseContexts();
64
55
 
65
56
  dependencyReleaseContexts.forEach((releaseContext) => {
66
- const releaseContextRules = releaseContext.getRules(releaseNames);
57
+ const includeDependencies = false,
58
+ releaseContextTypes = releaseContext.getTypes(includeDependencies);
67
59
 
68
- push(rules, releaseContextRules);
60
+ push(types, releaseContextTypes);
69
61
  });
70
62
  }
71
63
 
72
- return rules;
64
+ return types;
73
65
  }
74
66
 
75
- getAxioms(releaseNames = []) {
76
- const axioms = [],
77
- releaseName = this.getReleaseName(),
78
- releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
67
+ getRules(includeDependencies = true) {
68
+ const rules = [];
79
69
 
80
- if (!releaseNamesIncludesReleaseName) {
81
- releaseNames.push(releaseName);
82
-
83
- const bubble = false;
84
-
85
- this.fileContexts.forEach((fileContext) => {
86
- const fileContextAxioms = fileContext.getAxioms(bubble);
70
+ this.fileContexts.forEach((fileContext) => {
71
+ const includeRelease = false,
72
+ fileContextRules = fileContext.getRules(includeRelease);
87
73
 
88
- push(axioms, fileContextAxioms);
89
- });
74
+ push(rules, fileContextRules);
75
+ });
90
76
 
77
+ if (includeDependencies) {
91
78
  const dependencyReleaseContexts = this.getDependencyReleaseContexts();
92
79
 
93
80
  dependencyReleaseContexts.forEach((releaseContext) => {
94
- const releaseContextAxioms = releaseContext.getAxioms(releaseNames);
81
+ const includeDependencies = false,
82
+ releaseContextRules = releaseContext.getRules(includeDependencies);
95
83
 
96
- push(axioms, releaseContextAxioms);
84
+ push(rules, releaseContextRules);
97
85
  });
98
86
  }
99
87
 
100
- return axioms;
88
+ return rules;
101
89
  }
102
90
 
103
- getLabels(releaseNames = []) {
104
- const labels = [],
105
- releaseName = this.getReleaseName(),
106
- releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
107
-
108
- if (!releaseNamesIncludesReleaseName) {
109
- releaseNames.push(releaseName);
110
-
111
- const bubble = false;
91
+ getAxioms(includeDependencies = true) {
92
+ const axioms = [];
112
93
 
113
- this.fileContexts.forEach((fileContext) => {
114
- const fileContextLabels = fileContext.getLabels(bubble);
94
+ this.fileContexts.forEach((fileContext) => {
95
+ const includeRelease = false,
96
+ fileContextAxioms = fileContext.getAxioms(includeRelease);
115
97
 
116
- push(labels, fileContextLabels);
117
- });
98
+ push(axioms, fileContextAxioms);
99
+ });
118
100
 
101
+ if (includeDependencies) {
119
102
  const dependencyReleaseContexts = this.getDependencyReleaseContexts();
120
103
 
121
104
  dependencyReleaseContexts.forEach((releaseContext) => {
122
- const releaseContextLabels = releaseContext.getLabels(releaseNames);
105
+ const includeDependencies = false,
106
+ releaseContextAxioms = releaseContext.getAxioms(includeDependencies);
123
107
 
124
- push(labels, releaseContextLabels);
108
+ push(axioms, releaseContextAxioms);
125
109
  });
126
110
  }
127
111
 
128
- return labels;
112
+ return axioms;
129
113
  }
130
114
 
131
- getCombinators(releaseNames = []) {
132
- const combinators = [],
133
- releaseName = this.getReleaseName(),
134
- releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
135
-
136
- if (!releaseNamesIncludesReleaseName) {
137
- releaseNames.push(releaseName);
138
-
139
- const bubble = false;
115
+ getCombinators(includeDependencies = true) {
116
+ const combinators = [];
140
117
 
141
- this.fileContexts.forEach((fileContext) => {
142
- const fileContextCombinators = fileContext.getCombinators(bubble);
118
+ this.fileContexts.forEach((fileContext) => {
119
+ const includeRelease = false,
120
+ fileContextCombinators = fileContext.getCombinators(includeRelease);
143
121
 
144
- push(combinators, fileContextCombinators);
145
- });
122
+ push(combinators, fileContextCombinators);
123
+ });
146
124
 
125
+ if (includeDependencies) {
147
126
  const dependencyReleaseContexts = this.getDependencyReleaseContexts();
148
127
 
149
128
  dependencyReleaseContexts.forEach((releaseContext) => {
150
- const releaseContextCombinators = releaseContext.getCombinators(releaseNames);
129
+ const includeDependencies = false,
130
+ releaseContextCombinators = releaseContext.getCombinators(includeDependencies);
151
131
 
152
132
  push(combinators, releaseContextCombinators);
153
133
  });
@@ -156,26 +136,22 @@ export default class DirectoryReleaseContext extends ReleaseContext {
156
136
  return combinators;
157
137
  }
158
138
 
159
- getConstructors(releaseNames = []) {
160
- const constructors = [],
161
- releaseName = this.getReleaseName(),
162
- releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
139
+ getConstructors(includeDependencies = true) {
140
+ const constructors = [];
163
141
 
164
- if (!releaseNamesIncludesReleaseName) {
165
- releaseNames.push(releaseName);
166
-
167
- const bubble = false;
168
-
169
- this.fileContexts.forEach((fileContext) => {
170
- const fileContextConstructors = fileContext.getConstructors(bubble);
142
+ this.fileContexts.forEach((fileContext) => {
143
+ const includeRelease = false,
144
+ fileContextConstructors = fileContext.getConstructors(includeRelease);
171
145
 
172
- push(constructors, fileContextConstructors);
173
- });
146
+ push(constructors, fileContextConstructors);
147
+ });
174
148
 
149
+ if (includeDependencies) {
175
150
  const dependencyReleaseContexts = this.getDependencyReleaseContexts();
176
151
 
177
152
  dependencyReleaseContexts.forEach((releaseContext) => {
178
- const releaseContextConstructors = releaseContext.getConstructors(releaseNames);
153
+ const includeDependencies = false,
154
+ releaseContextConstructors = releaseContext.getConstructors(includeDependencies);
179
155
 
180
156
  push(constructors, releaseContextConstructors);
181
157
  });
package/src/context/release/file.js CHANGED
@@ -28,118 +28,103 @@ export default class FileReleaseContext extends ReleaseContext {
28
28
  return this.contextJSON;
29
29
  }
30
30
 
31
- getTypes(releaseNames = []) {
32
- const types = [],
33
- releaseName = this.getReleaseName(),
34
- releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
31
+ getLabels(includeDependencies = true) {
32
+ const labels = [];
35
33
 
36
- if (!releaseNamesIncludesReleaseName) {
37
- releaseNames.push(releaseName);
34
+ this.rules.forEach((rule) => {
35
+ const ruleLabels = rule.getLabels();
38
36
 
39
- push(types, this.types);
37
+ push(labels, ruleLabels);
38
+ });
39
+
40
+ this.axioms.forEach((axiom) => {
41
+ const axiomLabels = axiom.getLabels();
42
+
43
+ push(labels, axiomLabels);
44
+ });
40
45
 
46
+ if (includeDependencies) {
41
47
  const dependencyReleaseContexts = this.getDependencyReleaseContexts();
42
48
 
43
49
  dependencyReleaseContexts.forEach((releaseContext) => {
44
- const releaseContextTypes = releaseContext.getTypes(releaseNames);
50
+ const includeDependencies = false,
51
+ releaseContextAxioms = releaseContext.getAxioms(includeDependencies);
45
52
 
46
- push(types, releaseContextTypes);
53
+ push(labels, releaseContextAxioms);
47
54
  });
48
55
  }
49
56
 
50
- return types;
57
+ return labels;
51
58
  }
52
59
 
53
- getRules(releaseNames = []) {
54
- const rules = [],
55
- releaseName = this.getReleaseName(),
56
- releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
60
+ getTypes(includeDependencies = true) {
61
+ const types = [];
57
62
 
58
- if (!releaseNamesIncludesReleaseName) {
59
- releaseNames.push(releaseName);
60
-
61
- push(rules, this.rules);
63
+ push(types, this.types);
62
64
 
65
+ if (includeDependencies) {
63
66
  const dependencyReleaseContexts = this.getDependencyReleaseContexts();
64
67
 
65
68
  dependencyReleaseContexts.forEach((releaseContext) => {
66
- const releaseContextRules = releaseContext.getRules(releaseNames);
69
+ const includeDependencies = false,
70
+ releaseContextTypes = releaseContext.getTypes(includeDependencies);
67
71
 
68
- push(rules, releaseContextRules);
72
+ push(types, releaseContextTypes);
69
73
  });
70
74
  }
71
75
 
72
- return rules;
76
+ return types;
73
77
  }
74
78
 
75
- getAxioms(releaseNames = []) {
76
- const axioms = [],
77
- releaseName = this.getReleaseName(),
78
- releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
79
-
80
- if (!releaseNamesIncludesReleaseName) {
81
- releaseNames.push(releaseName);
79
+ getRules(includeDependencies = true) {
80
+ const rules = [];
82
81
 
83
- push(axioms, this.axioms);
82
+ push(rules, this.rules);
84
83
 
84
+ if (includeDependencies) {
85
85
  const dependencyReleaseContexts = this.getDependencyReleaseContexts();
86
86
 
87
87
  dependencyReleaseContexts.forEach((releaseContext) => {
88
- const releaseContextAxioms = releaseContext.getAxioms(releaseNames);
88
+ const includeDependencies = false,
89
+ releaseContextRules = releaseContext.getRules(includeDependencies);
89
90
 
90
- push(axioms, releaseContextAxioms);
91
+ push(rules, releaseContextRules);
91
92
  });
92
93
  }
93
94
 
94
- return axioms;
95
+ return rules;
95
96
  }
96
97
 
97
- getLabels(releaseNames = []) {
98
- const labels = [],
99
- releaseName = this.getReleaseName(),
100
- releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
101
-
102
- if (!releaseNamesIncludesReleaseName) {
103
- releaseNames.push(releaseName);
98
+ getAxioms(includeDependencies = true) {
99
+ const axioms = [];
104
100
 
105
- this.rules.forEach((rule) => {
106
- const ruleLabels = rule.getLabels();
107
-
108
- push(labels, ruleLabels);
109
- });
110
-
111
- this.axioms.forEach((axiom) => {
112
- const axiomLabels = axiom.getLabels();
113
-
114
- push(labels, axiomLabels);
115
- });
101
+ push(axioms, this.axioms);
116
102
 
103
+ if (includeDependencies) {
117
104
  const dependencyReleaseContexts = this.getDependencyReleaseContexts();
118
105
 
119
106
  dependencyReleaseContexts.forEach((releaseContext) => {
120
- const releaseContextAxioms = releaseContext.getAxioms(releaseNames);
107
+ const includeDependencies = false,
108
+ releaseContextAxioms = releaseContext.getAxioms(includeDependencies);
121
109
 
122
- push(labels, releaseContextAxioms);
110
+ push(axioms, releaseContextAxioms);
123
111
  });
124
112
  }
125
113
 
126
- return labels;
114
+ return axioms;
127
115
  }
128
116
 
129
- getCombinators(releaseNames = []) {
130
- const combinators = [],
131
- releaseName = this.getReleaseName(),
132
- releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
133
-
134
- if (!releaseNamesIncludesReleaseName) {
135
- releaseNames.push(releaseName);
117
+ getCombinators(includeDependencies = true) {
118
+ const combinators = [];
136
119
 
137
- push(combinators, this.combinators);
120
+ push(combinators, this.combinators);
138
121
 
122
+ if (includeDependencies) {
139
123
  const dependencyReleaseContexts = this.getDependencyReleaseContexts();
140
124
 
141
125
  dependencyReleaseContexts.forEach((releaseContext) => {
142
- const releaseContextCombinators = releaseContext.getCombinators(releaseNames);
126
+ const includeDependencies = false,
127
+ releaseContextCombinators = releaseContext.getCombinators(includeDependencies);
143
128
 
144
129
  push(combinators, releaseContextCombinators);
145
130
  });
@@ -148,20 +133,17 @@ export default class FileReleaseContext extends ReleaseContext {
148
133
  return combinators;
149
134
  }
150
135
 
151
- getConstructors(releaseNames = []) {
152
- const constructors = [],
153
- releaseName = this.getReleaseName(),
154
- releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
155
-
156
- if (!releaseNamesIncludesReleaseName) {
157
- releaseNames.push(releaseName);
136
+ getConstructors(includeDependencies = true) {
137
+ const constructors = [];
158
138
 
159
- push(constructors, this.constructors);
139
+ push(constructors, this.constructors);
160
140
 
141
+ if (includeDependencies) {
161
142
  const dependencyReleaseContexts = this.getDependencyReleaseContexts();
162
143
 
163
144
  dependencyReleaseContexts.forEach((releaseContext) => {
164
- const releaseContextConstructors = releaseContext.getConstructors(releaseNames);
145
+ const includeDependencies = false,
146
+ releaseContextConstructors = releaseContext.getConstructors(includeDependencies);
165
147
 
166
148
  push(constructors, releaseContextConstructors);
167
149
  });
package/src/utilities/releaseContext.js CHANGED
@@ -12,9 +12,9 @@ export function createReleaseContext(releaseName, dependentNames, shortenedVersi
12
12
  return;
13
13
  }
14
14
 
15
- const { releaseContextFromReleaseName } = context;
15
+ const { releaseContextFromReleaseNameAndShortenedVersion } = context;
16
16
 
17
- releaseContextFromReleaseName(releaseName, context, (releaseContext) => {
17
+ releaseContextFromReleaseNameAndShortenedVersion(releaseName, shortenedVersion, context, (releaseContext) => {
18
18
  if (releaseContext === null) {
19
19
  const error = true;
20
20
 
@@ -23,16 +23,6 @@ export function createReleaseContext(releaseName, dependentNames, shortenedVersi
23
23
  return;
24
24
  }
25
25
 
26
- const releaseMatchesShortedVersion = checkReleaseMatchesShortenedVersion(releaseContext, shortenedVersion);
27
-
28
- if (!releaseMatchesShortedVersion) {
29
- const error = true;
30
-
31
- callback(error);
32
-
33
- return;
34
- }
35
-
36
26
  createDependencyReleaseContexts(releaseContext, dependentNames, context, (error) => {
37
27
  if (!error) {
38
28
  releaseContextMap[releaseName] = releaseContext;
@@ -150,19 +140,3 @@ function retrieveDependencyReleaseContexts(releaseContext, releaseContextMap, de
150
140
 
151
141
  return dependencyReleaseContexts;
152
142
  }
153
-
154
- function checkReleaseMatchesShortenedVersion(releaseContext, shortenedVersion) {
155
- const entries = releaseContext.getEntries(),
156
- releaseMatchesShortedVersion = entries.matchShortenedVersion(shortenedVersion);
157
-
158
- if (!releaseMatchesShortedVersion) {
159
- const version = releaseContext.getVersion(),
160
- releaseName = releaseContext.getReleaseName(),
161
- versionString = version.toString(),
162
- shortenedVersionString = shortenedVersion.toString();
163
-
164
- releaseContext.error(`The '${releaseName}' package's version of ${versionString} does not match the dependency's shortened version of ${shortenedVersionString}.`);
165
- }
166
-
167
- return releaseMatchesShortedVersion;
168
- }