diff --git a/ModuleConfig.cfc b/ModuleConfig.cfc
index a9ccff77..f7165477 100644
--- a/ModuleConfig.cfc
+++ b/ModuleConfig.cfc
@@ -81,7 +81,6 @@ component {
interceptorSettings = {
customInterceptionPoints : [
"onCBWireMount",
- "onCBWireRenderIt",
"onCBWireSubsequentRenderIt"
]
};
@@ -94,7 +93,6 @@ component {
// Mounting
{ class : "#moduleMapping#.interceptors.ComponentMounting" },
// Rendering
- { class : "#moduleMapping#.interceptors.InitialComponentRendering" },
{ class : "#moduleMapping#.interceptors.SubsequentComponentRendering" },
{ class : "#moduleMapping#.interceptors.AutoInjectAssets" },
// Output
diff --git a/box.json b/box.json
index 799a3cf6..9da49d47 100644
--- a/box.json
+++ b/box.json
@@ -21,7 +21,9 @@
}
],
"contributors": [],
- "dependencies": {},
+ "dependencies": {
+ "cbjavaloader": "^2.1.1+8"
+ },
"devDependencies": {
"commandbox-cfformat": "*",
"commandbox-docbox": "*"
@@ -42,5 +44,7 @@
"testbox": {
"runner": "http://localhost:60299/tests/runner.cfm"
},
- "installPaths": {}
+ "installPaths": {
+ "cbjavaloader": "modules/cbjavaloader/"
+ }
}
\ No newline at end of file
diff --git a/helpers/helpers.cfm b/helpers/helpers.cfm
index 2cad2a13..0a0c09c8 100644
--- a/helpers/helpers.cfm
+++ b/helpers/helpers.cfm
@@ -22,15 +22,16 @@
}
/**
- * Instantiates our cbwire component, mounts it,
- * and then calls it's internal renderIt() method.
- *
- * @componentName String | The name of the component to load.
- * @parameters Struct | The parameters you want mounted initially.
- *
- * @return Component
- */
- function wire( componentName, parameters = {}, key = "" ) {
- return getInstance( "CBWireService@cbwire" ).wire( argumentCollection=arguments );
+ * Instantiates a CBWIRE component, mounts it,
+ * and then calls its internal renderIt() method.
+ *
+ * @param name The name of the component to load.
+ * @param params The parameters you want mounted initially. Defaults to an empty struct.
+ * @param key An optional key parameter. Defaults to an empty string.
+ *
+ * @return An instance of the specified component after rendering.
+ */
+ function wire(required string name, struct params = {}, string key = "") {
+ return getInstance("CBWIREController@cbwire").wire( argumentCollection=arguments );
}
diff --git a/interceptors/InitialComponentRendering.cfc b/interceptors/InitialComponentRendering.cfc
deleted file mode 100644
index 2c6da383..00000000
--- a/interceptors/InitialComponentRendering.cfc
+++ /dev/null
@@ -1,10 +0,0 @@
-component {
-
- function onCBWireRenderIt( required event, required data ){
- var cbwireComponent = data.component;
- var componentName = lCase( getMetadata( cbwireComponent ).name );
- event.setValue( "_cbwire_rendering", cbwireComponent.view( view="wires/#listLast( componentName, "." )#" ) );
- event.setValue( "_cbwire_rendering_raw", cbwireComponent.view( view="wires/#listLast( componentName, "." )#", applyWiring=false ) );
- }
-
-}
\ No newline at end of file
diff --git a/models/renderer/BaseRenderer.cfc b/models/renderer/BaseRenderer.cfc
index 268d7b2b..d4dcd1ef 100644
--- a/models/renderer/BaseRenderer.cfc
+++ b/models/renderer/BaseRenderer.cfc
@@ -1021,4 +1021,12 @@ component accessors="true" {
}
}
+ function getDataProperties(){
+ var props = variables.dataProperties;
+ // Merge properties defined with property tag
+ getParent().getPropertyTagDataProperties().each( function( prop ) {
+ props[ prop.name ] = getParent().getVariables()[ prop.name ];
+ } );
+ return props;
+ }
}
diff --git a/models/renderer/RendererEncapsulator.cfm b/models/renderer/RendererEncapsulator.cfm
index cb85ff75..e901d5ee 100755
--- a/models/renderer/RendererEncapsulator.cfm
+++ b/models/renderer/RendererEncapsulator.cfm
@@ -19,7 +19,7 @@
return attributes.event.getController().getRenderer().view( argumentCollection=arguments );
};
- getMetaData( attributes.cbwirecomponent.getParent() ).functions.each( function( cbwireFunction ) {
+ attributes.cbwirecomponent.getParent().getMetaInfo().functions.each( function( cbwireFunction ) {
variables[ cbwireFunction.name ] = function() {
return invoke( attributes.cbwireComponent.getParent(), cbwireFunction.name, arguments );
};
diff --git a/models/v4/CBWIREController.cfc b/models/v4/CBWIREController.cfc
new file mode 100644
index 00000000..4fec28dd
--- /dev/null
+++ b/models/v4/CBWIREController.cfc
@@ -0,0 +1,78 @@
+component {
+
+ property name="wirebox" inject="wirebox";
+
+ /**
+ * Instantiates a CBWIRE component, mounts it,
+ * and then calls its internal renderIt() method.
+ *
+ * @param name The name of the component to load.
+ * @param params The parameters you want mounted initially. Defaults to an empty struct.
+ * @param key An optional key parameter. Defaults to an empty string.
+ *
+ * @return An instance of the specified component after rendering.
+ */
+ function wire(required string name, struct params = {}, string key = "") {
+ return wirebox.getInstance("CBWIREController@cbwire")
+ .createInstance(argumentCollection=arguments)
+ ._withParams( arguments.params )
+ ._withKey( arguments.key )
+ ._withHTTPRequestData( getHTTPRequestData() )
+ .renderIt();
+ }
+
+ /**
+ * Handles incoming AJAX requests to update or interact with CBWIRE components.
+ *
+ * @param payload The JSON string payload of the incoming request.
+ * @return A JSON string representing the response with updated component details or an error message.
+ */
+ public string function handleRequest(required string payload) {
+ // Implementation of AJAX request handling
+ var data = deserializeJson(arguments.payload);
+ var responseComponents = [];
+ var isValidRequest = true;
+
+ // Example logic for processing a request
+ data.components.each(function(componentData) {
+ var componentInstance = createInstance(componentData.memo.name); // This method needs to be defined or adjusted according to your logic for instantiation
+ // Further processing...
+ });
+
+ if (!isValidRequest) {
+ return serializeJson({ "error": "Invalid request detected." });
+ }
+
+ return serializeJson({ "components": responseComponents });
+ }
+
+ /**
+ * Dynamically creates an instance of a CBWIRE component based on the provided name.
+ * Assumes components are located within a specific namespace or directory structure.
+ *
+ * @param componentName The name of the component to instantiate, possibly including a namespace.
+ * @param params Optional parameters to pass to the component constructor.
+ * @param key Optional key to use when retrieving the component from WireBox.
+ * @return The instantiated component object.
+ * @throws ApplicationException If the component cannot be found or instantiated.
+ */
+ public any function createInstance(required string name ) {
+ // Determine if the component name traverses a valid namespace or directory structure
+ var fullComponentPath = arguments.name;
+
+ if (!fullComponentPath contains "wires.") {
+ fullComponentPath = "wires." & fullComponentPath;
+ }
+
+ try {
+ // Attempt to create an instance of the component
+ return wirebox.getInstance(fullComponentPath);
+ } catch (Any e) {
+ writeDump( e );
+ abort;
+ // Log error or handle it as needed
+ throw("ApplicationException", "Unable to instantiate component '#arguments.name#'. Detail: #e.message#");
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/models/v4/Component.cfc b/models/v4/Component.cfc
new file mode 100644
index 00000000..b89d1209
--- /dev/null
+++ b/models/v4/Component.cfc
@@ -0,0 +1,339 @@
+component accessors="true" {
+
+ property name="_id";
+ property name="_params";
+ property name="_key";
+ property name="_httpRequestData";
+ property name="_metaData";
+ property name="_cache"; // internal cache for storing data
+ property name="data"; // Used for backwards compatibility
+ property name="args"; // Used for backwards compatibility
+
+ /**
+ * Initializes the component, setting a unique ID if not already set.
+ * This method should be called by any extending component's init method if overridden.
+ * Extending components should invoke super.init() to ensure the base initialization is performed.
+ * @return The initialized component instance.
+ */
+ public function init() {
+ if (len(trim(get_Id())) == 0) {
+ set_Id(createUUID());
+ }
+ set_Params( {} );
+ set_Key( "" );
+ set_HttpRequestData( {} );
+ set_Cache( {} );
+
+ /*
+ If the 'data' key exists in the variables scope, merge its contents
+ into the variables scope to preserve backwards compatibility with
+ prior versions of CBWIRE.
+ */
+ if ( variables.keyExists( "data") ) {
+ data.each( function( key, value ) {
+ variables[ key ] = value;
+ } );
+ }
+
+ /*
+ Create a reference to the variables scope called
+ 'data' to preserve backwards compatibility with
+ prior versions of CBWIRE.
+ */
+ setData( variables );
+
+ /*
+ Create a reference to the variables scope called
+ 'args' to preserve backwards compatibility with
+ prior versions of CBWIRE.
+ */
+ setArgs( variables );
+
+ /*
+ Cache the component's meta data on initialization
+ for fast access where needed.
+ */
+ set_MetaData( getMetaData(this) );
+
+ /*
+ Prep our computed properties for caching
+ */
+ _prepareComputedProperties();
+
+ return this;
+ }
+
+ /**
+ * Renders the component's HTML output.
+ * This method should be overridden by subclasses to implement specific rendering logic.
+ * @return The HTML representation of the component.
+ */
+ public string function renderIt() {
+ throw("AbstractMethodException", "This method is abstract and must be overridden in the subclass.");
+ }
+
+ /**
+ * Passes params to the component to be used with onMount.
+ *
+ * @return Component
+ */
+ public Component function _withParams( required struct params ) {
+ set_Params( arguments.params );
+
+ // Fire onMount if it exists
+ if (structKeyExists(this, "onMount")) {
+ onMount( params=arguments.params );
+ }
+
+ return this;
+ }
+
+ /**
+ * Passes HTTP request data to the component to be used with onMount.
+ * This method is useful for passing request data to the component for use in rendering.
+ *
+ * @param httpRequestData A struct containing the HTTP request data.
+ * @return Component
+ */
+ public Component function _withHTTPRequestData( required struct httpRequestData ) {
+ set_HttpRequestData( arguments.httpRequestData );
+ return this;
+ }
+
+ /**
+ * Passes a key to the component to be used to identify the component
+ * on subsequent requests.
+ *
+ * @return Component
+ */
+ public Component function _withKey( required string key ) {
+ set_Key( arguments.key );
+
+ return this;
+ }
+
+ /**
+ * Renders a specified view by converting dot notation to path notation and appending .cfm if necessary.
+ * Then, it returns the HTML content.
+ *
+ * @param viewPath The dot notation path to the view template to be rendered, without the .cfm extension.
+ * @param params A struct containing the parameters to be passed to the view template.
+ * @return The rendered HTML content as a string.
+ */
+ public string function view(required string viewPath, params = {} ) {
+ // Normalize the view path: convert dot notation to path notation, and ensure it starts with "/wires/"
+ var normalizedPath = replace(viewPath, ".", "/", "all");
+
+ // Check if ".cfm" is present; if not, append it.
+ if (not findNoCase(".cfm", normalizedPath)) {
+ normalizedPath &= ".cfm";
+ }
+
+ // Ensure the path starts with "/wires/" without duplicating it
+ if (left(normalizedPath, 6) != "wires/") {
+ normalizedPath = "wires/" & normalizedPath;
+ }
+
+ // Prepend a leading slash if not present
+ if (left(normalizedPath, 1) != "/") {
+ normalizedPath = "/" & normalizedPath;
+ }
+
+ var trimmedHTML = trim( _renderViewContent(normalizedPath, params) );
+
+ // Validate the HTML content to ensure it has a single outer element
+ _validateSingleOuterElement(trimmedHTML);
+
+ // Prepare the snapshot data for the Livewire attributes
+ var snapshot = {
+ "data": {"count": getCount()},
+ "memo": {
+ "id": get_Id(),
+ "name": "Counter",
+ "path": "counter"
+ // Additional properties as necessary
+ }
+ };
+
+ // Encode the snapshot for HTML attribute inclusion and process the view content
+ var snapshotEncoded = _encode_for_html_attribute(serializeJson(snapshot));
+
+ // Insert Livewire-specific attributes into the HTML content
+ return _insert_livewire_attributes(trimmedHTML, snapshotEncoded, get_Id());
+ }
+
+ /**
+ * Fires when missing methods are called.
+ * Handles computed properties.
+ *
+ * @return any
+ */
+ public function onMissingMethod( missingMethodName, missingMethodArguments ){
+ /*
+ Check the component's meta data for functions
+ labeled as computed.
+ */
+ var meta = get_MetaData();
+
+ /*
+ Throw an exception if the missing method is not a computed property.
+ */
+ throw( type="MissingMethodException", message="The method #arguments.missingMethodName# does not exist." );
+ }
+
+ /**
+ * Generates a checksum for securing the component's snapshot data.
+ *
+ * @param snapshot A struct representing the component's state snapshot.
+ * @return String The generated checksum.
+ */
+ private string function _generate_checksum(required struct snapshot) {
+ var secretKey = "YourSecretKey"; // This key should be securely retrieved
+ return hash(serializeJson(arguments.snapshot) & secretKey, "SHA-256");
+ }
+
+ /**
+ * Encodes a given string for safe usage within an HTML attribute.
+ *
+ * @param value The string to be encoded.
+ * @return String The encoded string suitable for HTML attribute inclusion.
+ */
+ private string function _encode_for_html_attribute(required string value) {
+ return arguments.value.replaceNoCase( '"', """, "all" );
+ // return encodeForHTMLAttribute(arguments.value);
+ }
+
+ /**
+ * Inserts Livewire-specific attributes into the given HTML content, ensuring Livewire can manage the component.
+ *
+ * @param html The original HTML content to be processed.
+ * @param snapshotEncoded The encoded snapshot data for Livewire's consumption.
+ * @param id The component's unique identifier.
+ * @return String The HTML content with Livewire attributes properly inserted.
+ */
+ private string function _insert_livewire_attributes(required string html, required string snapshotEncoded, required string id) {
+ // Locate the position to insert Livewire attributes right after the opening tag
+ var firstTagEnd = find(">", html);
+ var isSelfClosing = find("/>", html, firstTagEnd - 1) == firstTagEnd - 1;
+ var livewireAttributes = ' wire:snapshot="' & snapshotEncoded & '" wire:effects="[]" wire:id="' & id & '"';
+
+ if (isSelfClosing) {
+ // Insert attributes before self-closing tag's />
+ return left(html, firstTagEnd - 2) & livewireAttributes & "/>" & right(html, len(html) - firstTagEnd);
+ } else {
+ // Insert attributes into the opening tag
+ return left(html, firstTagEnd) & livewireAttributes & right(html, len(html) - firstTagEnd);
+ }
+ }
+
+ /**
+ * Renders the content of a view template file.
+ * This method is used internally by the view method to render the content of a view template.
+ * @param normalizedPath The normalized path to the view template file.
+ * @return The rendered content of the view template.
+ */
+ private function _renderViewContent( required normalizedPath, params = {} ){
+
+ /*
+ Take any params passed to the view method and make them available as variables
+ within the view template. This allows for dynamic content to be rendered based on
+ the parameters passed to the view method.
+ */
+ params.each( function( key, value ) {
+ variables[ key ] = value;
+ } );
+
+ var viewContent = "";
+ savecontent variable="viewContent" {
+ // The leading slash in the include path might need to be removed depending on your server setup
+ // or application structure, as cfinclude paths are relative to the application root.
+ include "#normalizedPath#"; // Dynamically includes the CFML file for processing.
+ }
+ return viewContent;
+ }
+
+ /**
+ * Validates that the HTML content has a single outer element.
+ * Ensures the first and last tags match and that the total number of tags is even.
+ *
+ * @param trimmedHtml The trimmed HTML content to validate.
+ * @throws ApplicationException When the HTML does not meet the single outer element criteria.
+ */
+ private void function _validateSingleOuterElement(required string trimmedHtml) {
+ return; // Skip validation for now
+ // Load Jsoup and parse the HTML content
+ var jsoup = createObject("java", "org.jsoup.Jsoup");
+ var doc = jsoup.parse(trimmedHtml);
+ var body = doc.body();
+
+ // Jsoup treats both text nodes and element nodes as Elements, so filter only for element nodes
+ var elements = body.children();
+ var count = 0;
+
+ // Iterate over child elements of the body, counting non-script elements
+ for (var element in elements) {
+ if (!element.tagName().equalsIgnoreCase("script")) {
+ count++;
+ }
+ }
+
+ // If more than one non-script child element is found, throw an exception
+ if (count > 1) {
+ throw("ApplicationException", "Multiple root elements detected.");
+ }
+ }
+
+ /**
+ * Get the components properties using meta data
+ *
+ * @return struct
+ */
+ public struct function _getDataProperties() {
+ var properties = get_MetaData().properties;
+ return properties.reduce( function( result, prop ) {
+ result[prop.name] = invoke( this, "get" & prop.name );
+ return result;
+ } );
+ }
+
+ /*
+ This method will iterate over the component's meta data
+ and prepare any functions labeled as computed for caching.
+
+ @return void
+ */
+ private function _prepareComputedProperties() {
+
+ /*
+ Filter the component's meta data for functions labeled as computed.
+ For each computed function, generate a computed property
+ that caches the result of the computed function.
+ */
+ get_MetaData().functions.filter( function( func ) {
+ return structKeyExists(func, "computed");
+ } ).each( function( func ) {
+ _generateComputedProperty( func.name, this[func.name] );
+ } );
+
+ /*
+ Look for additional computed properties defined in the 'computed'
+ variable scope and generate computed properties for each.
+ */
+ if ( variables.keyExists( "computed" ) ) {
+ variables.computed.each( function( key, value ) {
+ _generateComputedProperty( key, value );
+ } );
+ }
+ }
+
+ private function _generateComputedProperty( required string name, required function method ) {
+ var computedPropName = arguments.name;
+ var computedMethodRef = arguments.method;
+ this[computedPropName] = function( cacheMethod = true ) {
+ if ( !variables._cache.keyExists(computedPropName ) || !arguments.cacheMethod ) {
+ variables._cache[computedPropName] = computedMethodRef( argumentCollection=arguments );
+ }
+ return variables._cache[computedPropName];
+ };
+ }
+}
diff --git a/test-harness/tests/specs/CBWIRE4Spec.cfc b/test-harness/tests/specs/CBWIRE4Spec.cfc
new file mode 100644
index 00000000..2f25572d
--- /dev/null
+++ b/test-harness/tests/specs/CBWIRE4Spec.cfc
@@ -0,0 +1,166 @@
+component extends="coldbox.system.testing.BaseTestCase" {
+
+ // Lifecycle methods and BDD suites as before...
+
+ function run(testResults, testBox) {
+ describe("Counter.cfc", function() {
+
+ beforeEach(function(currentSpec) {
+ // Assuming setup() initializes application environment
+ // and prepareMock() is a custom method to mock any dependencies, if necessary.
+ setup();
+ comp = getInstance("wires.Counter");
+ prepareMock( comp );
+ });
+
+ it("is an object", function() {
+ expect(isObject(comp)).toBeTrue();
+ });
+
+ it("initial count is 1", function() {
+ expect(comp.getCount()).toBe(1);
+ });
+
+ it("increments count", function() {
+ comp.increment();
+ expect(comp.getCount()).toBe(2);
+ });
+
+ it("decrements count", function() {
+ comp.decrement();
+ expect(comp.getCount()).toBe(0);
+ });
+
+ it("renders with correct snapshot, effects, and id attribute", function() {
+ comp.$("_renderViewContent", "
test
" );
+ var renderedHtml = comp.renderIt();
+ expect(renderedHtml.contains('wire:snapshot="{')).toBeTrue();
+ expect(renderedHtml.contains('wire:effects="[]')).toBeTrue();
+ expect(renderedHtml.contains('id="')).toBeTrue();
+ });
+
+ it("can render a view template", function() {
+ var viewContent = comp.view("wires.Counter"); // Adjust based on your view's location
+ expect(viewContent).toInclude("Counter: 1");
+ });
+
+ it("can pass additional data to the view", function() {
+ var viewContent = comp.view("wires.Counter", { count: 5 });
+ expect(viewContent).toInclude("Counter: 5");
+ });
+
+ it("can access properties using 'data' dot for backwards compatability", function() {
+ var viewContent = comp.view("wires.CounterUsingDataDot" );
+ expect(viewContent).toInclude("Counter: 1");
+ });
+
+ it("decrements count using 'data' dot", function() {
+ comp.decrementWithDataDot();
+ expect(comp.getCount()).toBe(0);
+ });
+
+ it("can access properties using 'args' dot for backwards compatability", function() {
+ var viewContent = comp.view("wires.CounterUsingArgsDot" );
+ expect(viewContent).toInclude("Counter: 1");
+ });
+
+ it( "supports computed properties", function() {
+ expect( comp.countPlusTen() ).toBe( 11 );
+ } );
+
+ it( "computed properties are cached", function() {
+ var result1 = comp.tick();
+ sleep( 10 );
+ var result2 = comp.tick();
+ expect( result1 ).toBe( result2 );
+ } );
+
+ it( "computed properties can accept false flag to prevent caching", function() {
+ var result1 = comp.tick();
+ sleep( 10 );
+ var result2 = comp.tick( false );
+ expect( result1 ).notToBe( result2 );
+ } );
+
+ it( "computed property can be accessed from view", function() {
+ var viewContent = comp.view("wires.CounterUsingComputedProperty" );
+ expect(viewContent).toInclude("Counter: 11");
+ } );
+
+ xit("throws an exception for a non-existent view", function() {
+ expect(function() {
+ comp.view("nonExistentView.cfm");
+ }).toThrow();
+ });
+
+ xit("throws an error for HTML without a single outer element", function() {
+ // Override MyComponent's view method to return HTML without a single outer element for this test
+ comp.$("_renderViewContent", "
First Element
Second Element
" );
+
+ expect(function() {
+ comp.renderIt();
+ }).toThrow("The rendered HTML must have a single outer element.");
+ });
+
+ });
+
+ describe( "CounterUsingCBWIRE3.cfc", function() {
+
+ beforeEach(function(currentSpec) {
+ // Assuming setup() initializes application environment
+ // and prepareMock() is a custom method to mock any dependencies, if necessary.
+ setup();
+ comp = getInstance("wires.CounterUsingCBWIRE3");
+ prepareMock( comp );
+ });
+
+ it("is an object", function() {
+ expect(isObject(comp)).toBeTrue();
+ });
+
+ it("initial count is 1", function() {
+ expect(comp.getData().count).toBe(1);
+ });
+
+ it("increments count", function() {
+ comp.increment();
+ expect(comp.getData().count).toBe(2);
+ });
+
+ it("decrements count", function() {
+ comp.decrement();
+ expect(comp.getData().count).toBe(0);
+ });
+
+ it( "supports computed properties", function() {
+ expect( comp.countPlusTen() ).toBe( 11 );
+ } );
+
+ it( "computed properties are cached", function() {
+ var result1 = comp.tick();
+ sleep( 10 );
+ var result2 = comp.tick();
+ expect( result1 ).toBe( result2 );
+ } );
+
+ } );
+
+ describe("CBWIREController", function() {
+
+ beforeEach(function(currentSpec) {
+ // Assuming setup() initializes application environment
+ // and prepareMock() is a custom method to mock any dependencies, if necessary.
+ setup();
+ cbwireController = getInstance("CBWIREController@cbwire");
+ prepareMock( cbwireController );
+ });
+
+ it( "wire calls onMount", function() {
+ var result = cbwireController.createInstance( "Counter" );
+ expect( result ).toInclude( "Counter: 10" );
+ } );
+
+
+ });
+ }
+}
diff --git a/test-harness/views/examples/index.cfm b/test-harness/views/examples/index.cfm
index afc02b16..ee6bfc95 100644
--- a/test-harness/views/examples/index.cfm
+++ b/test-harness/views/examples/index.cfm
@@ -27,6 +27,10 @@