2
2
3
3
namespace Okapi \CodeTransformer ;
4
4
5
- use Okapi \CodeTransformer \Exception \Kernel \DirectKernelInitializationException ;
6
- use Okapi \CodeTransformer \Service \AutoloadInterceptor ;
7
- use Okapi \CodeTransformer \Service \CacheStateManager ;
8
- use Okapi \CodeTransformer \Service \Options ;
9
- use Okapi \CodeTransformer \Service \StreamFilter ;
10
- use Okapi \CodeTransformer \Service \TransformerContainer ;
5
+ use DI \Attribute \Inject ;
6
+ use Okapi \CodeTransformer \Core \AutoloadInterceptor ;
7
+ use Okapi \CodeTransformer \Core \Cache \CacheStateManager ;
8
+ use Okapi \CodeTransformer \Core \Container \TransformerManager ;
9
+ use Okapi \CodeTransformer \Core \DI ;
10
+ use Okapi \CodeTransformer \Core \Exception \Kernel \DirectKernelInitializationException ;
11
+ use Okapi \CodeTransformer \Core \Options ;
12
+ use Okapi \CodeTransformer \Core \StreamFilter ;
11
13
use Okapi \Singleton \Singleton ;
12
14
13
15
/**
14
16
* # Code Transformer Kernel
15
17
*
16
- * The `CodeTransformerKernel` is the heart of the Code Transformer library.
18
+ * This class is the heart of the Code Transformer library.
17
19
* It manages an environment for Code Transformation.
18
20
*
19
21
* 1. Extends this class and define a list of transformers in the
@@ -24,6 +26,58 @@ abstract class CodeTransformerKernel
24
26
{
25
27
use Singleton;
26
28
29
+ // region DI
30
+
31
+ #[Inject]
32
+ private Options $ options ;
33
+
34
+ #[Inject]
35
+ protected TransformerManager $ transformerContainer ;
36
+
37
+ #[Inject]
38
+ private CacheStateManager $ cacheStateManager ;
39
+
40
+ #[Inject]
41
+ private StreamFilter $ streamFilter ;
42
+
43
+ #[Inject]
44
+ private AutoloadInterceptor $ autoloadInterceptor ;
45
+
46
+ /**
47
+ * Make the constructor public to allow the DI container to instantiate the class.
48
+ */
49
+ public function __construct () {}
50
+
51
+ // endregion
52
+
53
+ // region Settings
54
+
55
+ /**
56
+ * The cache directory.
57
+ * <br><b>Default:</b> ROOT_DIR/cache/code-transformer<br>
58
+ *
59
+ * @var string|null
60
+ */
61
+ protected ?string $ cacheDir = null ;
62
+
63
+ /**
64
+ * The cache file mode.
65
+ * <br><b>Default:</b> 0777 & ~{@link umask()}<br>
66
+ *
67
+ * @var int|null
68
+ */
69
+ protected ?int $ cacheFileMode = null ;
70
+
71
+ /**
72
+ * Enable debug mode. This will disable the cache.
73
+ * <br><b>Default:</b> false<br>
74
+ *
75
+ * @var bool
76
+ */
77
+ protected bool $ debug = false ;
78
+
79
+ // endregion
80
+
27
81
/**
28
82
* List of transformers to be applied.
29
83
*
@@ -32,47 +86,67 @@ abstract class CodeTransformerKernel
32
86
protected array $ transformers = [];
33
87
34
88
/**
35
- * Initialize the kernel .
89
+ * Resolve instance with dependency injection .
36
90
*
37
- * @param string|null $cacheDir The cache directory.
38
- * <br><b>Default:</b> ROOT_DIR/cache/code-transformer<br>
39
- * @param int|null $cacheFileMode The cache file mode.
40
- * <br><b>Default:</b> 0777 & ~{@link umask()}<br>
41
- * @param bool|null $debug Enable debug mode. This will disable the cache.
42
- * <br><b>Default:</b> false<br>
91
+ * @inheritDoc
92
+ */
93
+ public static function getInstance (): static
94
+ {
95
+ if (!isset (static ::$ instance )) {
96
+ static ::registerDependencyInjection ();
97
+
98
+ static ::$ instance = DI ::get (static ::class);
99
+ }
100
+
101
+ return static ::$ instance ;
102
+ }
103
+
104
+ /**
105
+ * Initialize the kernel.
43
106
*
44
107
* @return void
45
108
*/
46
- public static function init (
47
- ?string $ cacheDir ,
48
- ?int $ cacheFileMode = null ,
49
- bool $ debug = false ,
50
- ): void {
51
- self ::ensureNotKernelNamespace ();
52
-
53
- $ instance = self ::getInstance ();
54
- $ instance ->ensureNotInitialized ();
109
+ public static function init (): void
110
+ {
111
+ static ::ensureNotKernelNamespace ();
55
112
56
- // Only initialize the kernel if there are transformers
57
- if ($ instance ->transformers ) {
58
- // Pre-initialize the services
113
+ $ instance = static ::getInstance ();
114
+ $ instance ->ensureNotInitialized ();
59
115
60
- // Set options
61
- Options::setOptions (
62
- cacheDir: $ cacheDir ,
63
- cacheFileMode: $ cacheFileMode ,
64
- debug: $ debug ,
65
- );
116
+ // Initialize the services
117
+ $ instance ->preInit ();
118
+ $ instance ->registerServices ();
119
+ $ instance ->registerAutoloadInterceptor ();
66
120
67
- // Add the transformers
68
- TransformerContainer:: addTransformers ( $ instance -> transformers );
121
+ $ instance -> setInitialized ();
122
+ }
69
123
70
- // Register the services
71
- $ instance ->registerServices ();
72
- $ instance ->registerAutoloadInterceptor ();
73
- }
124
+ /**
125
+ * Register the dependency injection.
126
+ *
127
+ * @return void
128
+ */
129
+ protected static function registerDependencyInjection (): void
130
+ {
131
+ DI ::getInstance ()->register ();
132
+ }
74
133
75
- $ instance ->setInitialized ();
134
+ /**
135
+ * Pre-initialize the services.
136
+ *
137
+ * @return void
138
+ */
139
+ protected function preInit (): void
140
+ {
141
+ // Set options
142
+ $ this ->options ->setOptions (
143
+ cacheDir: $ this ->cacheDir ,
144
+ cacheFileMode: $ this ->cacheFileMode ,
145
+ debug: $ this ->debug ,
146
+ );
147
+
148
+ // Add the transformers
149
+ $ this ->transformerContainer ->addTransformers ($ this ->transformers );
76
150
}
77
151
78
152
/**
@@ -83,16 +157,16 @@ public static function init(
83
157
protected function registerServices (): void
84
158
{
85
159
// Options provider
86
- Options:: register ();
160
+ $ this -> options -> register ();
87
161
88
162
// Manage the user-defined transformers
89
- TransformerContainer:: register ();
163
+ $ this -> transformerContainer -> register ();
90
164
91
165
// Cache path manager
92
- CacheStateManager:: register ();
166
+ $ this -> cacheStateManager -> register ();
93
167
94
168
// Stream filter -> Source transformer
95
- StreamFilter:: register ();
169
+ $ this -> streamFilter -> register ();
96
170
}
97
171
98
172
/**
@@ -103,15 +177,15 @@ protected function registerServices(): void
103
177
protected function registerAutoloadInterceptor (): void
104
178
{
105
179
// Overload the composer class loaders
106
- AutoloadInterceptor:: register ();
180
+ $ this -> autoloadInterceptor -> register ();
107
181
}
108
182
109
183
/**
110
184
* Make sure that the kernel is not called from this class.
111
185
*
112
186
* @return void
113
187
*/
114
- private static function ensureNotKernelNamespace (): void
188
+ protected static function ensureNotKernelNamespace (): void
115
189
{
116
190
// Get current namespace and class name
117
191
$ namespace = get_called_class ();
0 commit comments