wfc 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9c9494460645247374def67bc05bd7c50f77ef72d7b0def2223a1b242880783
-  data.tar.gz: 619c0999e742305914bcc70d1223c5878e5a293cb4381dad9819a9c756a03eec
+  metadata.gz: f23f54514453d35efb89bf9d57f589e07580e71386e5258f482dd71d6f403dbb
+  data.tar.gz: bffde63c76c1be31f6569e38a0d7902191c21e857a22e928e415a4861754f3f8
 SHA512:
-  metadata.gz: 74b895aea1e783332fca9709ea72564253ea40f95891129478c21e2c4bd089b834bf4188d7f51c86f4cd1231cb573a59241dd128b4eb011cd55a29a3b0eb3dec
-  data.tar.gz: a149febdc30e90b6d6a6c9dc29a2d481414fc63a82a0d21f04e3d4911d9e4d31c328a68dec1f3f123a3b368851a1f1fab60470b4793759f524b0ecb67444b5f4
+  metadata.gz: d046af34057a308a955bcd014c30540044ab31b14c21d0846efc777105841d613ace4ef5a668a0979714de8f058103d1298cf271e9c7bdf21b760dfcfa27dc31
+  data.tar.gz: 58f6212bcb8f1985bed449d02e3408fde2626c2d73d1ab44a0b1e552530478e6d83b048198cd15945dd687e6f85f610e82e479245a534842b99968dc1c212311

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
-## [2.1.0] - 2026-09-10
+## [2.2.0] - 2026-10-05
 
-- Initial release of WebForms Core (WFC) for Ruby.
+- Addition of the powerful `render` method.
+- Addition of `snapshot` and `rollback` methods.
+- Addition of `GetTagHash` for detecting DOM changes.
+- Addition of Regex-based value formatting (`SetFormatCacheValue`, `SetFormatSaveValue`).
+- Addition of arithmetic and text operations for stored values.
+- Addition of Regex-based element selection in Criteria.
+- Addition of `Try`/`Catch` error handling.
+- Addition of `LockQueue` for explicit queue locking.
+- Addition of `SetCustomValidity` for native HTML validation.
+- Stable WebAssembly support across 7 languages.

data/README.md

@@ -1,20 +1,41 @@
-# WebForms Core (WFC)
+# WebForms Core
 
-WebForms Core (WFC) is a server-driven web interface technology for Ruby.
+## WFC for Ruby
 
-It provides a `WebForms` class for generating server-side commands that manipulate HTML elements and interact with the WebFormsJS runtime in the browser.
+**WFC** is the Ruby implementation of the **WebForms Core Commander**. It provides the `WebForms` class for generating WebForms Core commands from Ruby server-side applications.
 
-WebForms Core is developed by [Elanat](https://elanat.net).
+## WebForms Core Architecture
+
+WebForms Core consists of two main parts:
+
+- **Commander** — WebForms classes implemented for different programming languages. Commanders generate WebForms Core commands that describe changes to the HTML document.
+- **Executor** — **WebFormsJS**, the client-side JavaScript library that receives and executes those commands in the browser.
+
+The Ruby `WFC` implementation provides the **Commander** for Ruby, while WebFormsJS provides the common browser-side Executor.
+
+The WebFormsJS Executor is loaded into the HTML document:
+
+```html
+<script type="module" src="/script/web-forms.js"></script>
+```
+
+WebForms Core is a technology developed by [Elanat](https://elanat.net).
 
 ## Installation
 
-Install the gem:
+### Installation via RubyGems
+
+The package is available on RubyGems:
+
+https://rubygems.org/gems/wfc
+
+Install using RubyGems:
 
 ```bash
 gem install wfc
 ```
 
-Or add it to your application's Gemfile:
+Or add it to your application's `Gemfile`:
 
 ```ruby
 gem "wfc"
@@ -26,25 +47,32 @@ Then run:
 bundle install
 ```
 
-## Usage
+### Source Code
+
+The Ruby implementation is available in the WebForms Core classes repository:
+
+https://github.com/webforms-core/WebFormsClasses/tree/elanat_framework/ruby
 
-Require the gem:
+## How to Work with WebForms Core in Ruby
+
+The following example demonstrates how to use WFC in a Ruby server-side application.
 
 ```ruby
 require "wfc"
 
 include WebFormsCore
-```
 
-You can then create a `WebForms` instance and generate server-side commands:
-
-```ruby
 form = WebForms.new
 
-form.set_text("message", "Hello from WebForms Core!")
+form.set_text(
+  InputPlace.tag("body"),
+  "Hello from WebForms Core!"
+)
+
+puts form.response
 ```
 
-The generated commands are intended to be executed by the WebFormsJS runtime in the browser.
+The `WebForms` class generates WebForms Core commands on the server. These commands are returned to the browser and executed by WebFormsJS.
 
 ## How to Work with WebForms Core in Ruby (Sinatra Framework)
 
@@ -53,123 +81,292 @@ WebForms Core can be used with the [Sinatra](https://sinatrarb.com/) framework.
 After installing the `wfc` gem, require it in your Sinatra application:
 
 ```ruby
-require 'sinatra'
-require 'wfc'
+require "sinatra"
+require "wfc"
 
 include WebFormsCore
 ```
 
-The following example demonstrates a form that sends data to the server. The server then uses the `WebForms` class to generate commands that modify the page.
+The following example demonstrates a form that sends data to the server. The server then uses the `WebForms` class to generate commands that modify the existing HTML document.
 
 ```ruby
-require 'sinatra'
-require 'wfc'
+require "sinatra"
+require "wfc"
 
 include WebFormsCore
 
-get '/' do
+get "/" do
   erb :view
 end
 
-post '/' do
-  if params['btn_SetBodyValue']
-    name = params['txt_Name']
-    background_color = params['txt_BackgroundColor']
-    font_size = params['txt_FontSize'].to_i
+post "/" do
+  if params["btn_SetBodyValue"]
+    name = params["txt_Name"]
+    background_color = params["txt_BackgroundColor"]
+    font_size = params["txt_FontSize"].to_i
 
     form = WebForms.new
 
-    form.set_font_size(InputPlace.tag('form'), font_size)
-    form.set_background_color(InputPlace.tag('form'), background_color)
-    form.set_disabled(InputPlace.name('btn_SetBodyValue'), true)
+    form.set_font_size(
+      InputPlace.tag("form"),
+      font_size
+    )
 
-    form.add_tag(InputPlace.tag('form'), 'h3')
-    form.set_text(InputPlace.tag('h3'), "Welcome #{name}!")
+    form.set_background_color(
+      InputPlace.tag("form"),
+      background_color
+    )
+
+    form.set_disabled(
+      InputPlace.name("btn_SetBodyValue"),
+      true
+    )
+
+    form.add_tag(
+      InputPlace.tag("form"),
+      "h3"
+    )
+
+    form.set_text(
+      InputPlace.tag("h3"),
+      "Welcome #{name}!"
+    )
 
     return form.response
   end
 end
+```
 
-__END__
+The corresponding view can contain:
 
-@@view
+```html
 <!DOCTYPE html>
 <html>
 <head>
   <title>Using WebForms Core</title>
-  <script type="text/javascript" src="/script/web-forms.js"></script>
+  <script type="module" src="/script/web-forms.js"></script>
 </head>
 <body>
-    <form method="post" action="/" >
-
-        <label for="txt_Name">Your Name</label>
-        <input name="txt_Name" id="txt_Name" type="text" />
-        <br>
-        <label for="txt_FontSize">Set Font Size</label>
-        <input name="txt_FontSize" id="txt_FontSize" type="number" value="16" min="10" max="36" />
-        <br>
-        <label for="txt_BackgroundColor">Set Background Color</label>
-        <input name="txt_BackgroundColor" id="txt_BackgroundColor" type="text" />
-        <br>
-        <input name="btn_SetBodyValue" type="submit" value="Click to send data" />
-
-    </form>
+  <form method="post" action="/">
+    <label for="txt_Name">Your Name</label>
+    <input name="txt_Name" id="txt_Name" type="text">
+    <br>
+
+    <label for="txt_FontSize">Set Font Size</label>
+    <input
+      name="txt_FontSize"
+      id="txt_FontSize"
+      type="number"
+      value="16"
+      min="10"
+      max="36"
+    >
+    <br>
+
+    <label for="txt_BackgroundColor">
+      Set Background Color
+    </label>
+
+    <input
+      name="txt_BackgroundColor"
+      id="txt_BackgroundColor"
+      type="text"
+    >
+    <br>
+
+    <input
+      name="btn_SetBodyValue"
+      type="submit"
+      value="Click to send data"
+    >
+  </form>
 </body>
 </html>
 ```
 
-### How the Example Works
+## How the Ruby Example Works
 
-When the page is requested for the first time, the `GET /` route renders the complete view.
+When the page is requested for the first time, the `GET /` route renders the complete HTML view.
 
-When the submit button is clicked, the browser sends the form data to the `POST /` route. The server checks whether `btn_SetBodyValue` was submitted.
+The page includes the WebFormsJS Executor:
 
-If the button was submitted, a `WebForms` instance is created and WebForms Core methods are used to generate commands:
+```html
+<script type="module" src="/script/web-forms.js"></script>
+```
+
+When the form is submitted, Sinatra receives the submitted form data through `params`.
+
+If the submit button is included in the request, a `WebForms` instance is created:
 
 ```ruby
 form = WebForms.new
+```
 
-form.set_font_size(InputPlace.tag('form'), font_size)
-form.set_background_color(InputPlace.tag('form'), background_color)
-form.set_disabled(InputPlace.name('btn_SetBodyValue'), true)
+The application then generates WebForms Core commands:
 
-form.add_tag(InputPlace.tag('form'), 'h3')
-form.set_text(InputPlace.tag('h3'), "Welcome #{name}!")
+```ruby
+form.set_font_size(
+  InputPlace.tag("form"),
+  font_size
+)
+
+form.set_background_color(
+  InputPlace.tag("form"),
+  background_color
+)
+
+form.set_disabled(
+  InputPlace.name("btn_SetBodyValue"),
+  true
+)
 ```
 
-The generated response is then returned:
+Additional commands modify the HTML document:
+
+```ruby
+form.add_tag(
+  InputPlace.tag("form"),
+  "h3"
+)
+
+form.set_text(
+  InputPlace.tag("h3"),
+  "Welcome #{name}!"
+)
+```
+
+Finally, the generated WebForms Core response is returned:
 
 ```ruby
 return form.response
 ```
 
-In this case, the complete view is not rendered again. The response contains WebForms Core commands that are processed by WebFormsJS in the browser.
+WebFormsJS receives the response and executes the generated commands on the HTML DOM.
+
+In this case, the complete HTML view is not rendered again. The POST response contains WebForms Core commands that update the existing HTML document in the browser.
+
+This allows a Ruby server-side application to control the client-side HTML document through WebForms Core commands without requiring JavaScript code for each individual UI operation.
+
+## Sending Commands with the Initial HTML
+
+When WebForms Core commands need to be sent together with the initial HTML document, you can use `export_to_html_comment` instead of `response`.
+
+`export_to_html_comment` embeds the generated WebForms Core commands in an HTML comment. WebFormsJS detects these commands when the HTML document is loaded and executes them in the browser.
+
+For example:
 
-The initial `GET` request and subsequent `POST` request therefore have different purposes. The initial request renders the page, while the POST request can return WebForms Core commands to update the existing HTML.
+```ruby
+require "wfc"
+
+include WebFormsCore
 
-### WebFormsJS
+form = WebForms.new
 
-WebFormsJS is the client-side runtime that executes WebForms Core commands in the browser.
+form.set_background_color(
+  InputPlace.tag("body"),
+  "lightblue"
+)
+```
 
-Add the WebFormsJS script to the `<head>` section of your view:
+The generated commands can then be included in the HTML response using:
+
+```ruby
+form.export_to_html_comment
+```
+
+For example:
 
 ```html
-<script type="text/javascript" src="/script/web-forms.js"></script>
+<!DOCTYPE html>
+<html>
+<head>
+  <title>WebForms Core</title>
+  <script type="module" src="/script/web-forms.js"></script>
+</head>
+<body>
+  <h1>Hello World!</h1>
+</body>
+</html>
+<%= form.export_to_html_comment %>
 ```
 
-The latest WebFormsJS source is available in the [WebForms repository](https://github.com/elanatframework/Web_forms/blob/elanat_framework/web-forms.js).
+The generated WebForms Core commands are embedded in the HTML response itself. When WebFormsJS loads, it detects the commands in the HTML comment and executes them on the DOM.
 
-## WebForms Core Architecture
+Use `response` when returning WebForms Core commands as a response to a request. Use `export_to_html_comment` when the commands need to be included directly in the HTML document, such as during the initial page load.
+
+## Commander and Executor
+
+The `WebForms` class is the **Commander**. It generates WebForms Core commands that describe operations to be performed on the HTML document.
+
+For example:
 
-WebForms Core separates server-side command generation from client-side command execution.
+```ruby
+form = WebForms.new
+
+form.add_tag(
+  InputPlace.tag("body"),
+  "h3"
+)
+
+form.set_text(
+  InputPlace.tag("h3"),
+  "Hello World!"
+)
+
+form.set_background_color(
+  InputPlace.tag("body"),
+  "lightblue"
+)
+
+puts form.response
+```
+
+The Commander does not directly manipulate the browser DOM. It generates the WebForms Core response that is sent to the client.
+
+**WebFormsJS** is the **Executor**. It receives WebForms Core commands from the server and executes them in the browser.
+
+```text
+                   WebForms Core
+                        │
+             ┌──────────┴──────────┐
+             │                     │
+         Commander              Executor
+             │                     │
+         Ruby WFC              WebFormsJS
+             │                web-forms.js
+             │                     │
+    Generates commands ──► Executes commands
+                                   │
+                                   ▼
+                              Browser DOM
+```
+
+The **Commander describes what should happen**.
+
+The **Executor performs those commands in the browser**.
 
-* **WebForms** runs on the server and generates commands.
-* **WebFormsJS** runs in the browser and executes those commands.
-* HTML remains the primary interface.
-* No virtual DOM is required.
-* No client-side component framework is required.
+WebForms Core uses a **command-driven flow** and a **stateless server architecture**. The same WebForms Core programming model can be used across different programming languages and server-side environments.
 
-The Ruby implementation provides the server-side WebForms Core API.
+WebForms Core is available for web development in all major web programming languages.
+
+## WebFormsJS
+
+WebFormsJS is the client-side JavaScript **Executor** of WebForms Core.
+
+The latest WebFormsJS Executor is available here:
+
+- WebFormsJS on Elanat: https://elanat.net/webforms-js
+- WebFormsJS on GitHub: https://github.com/webforms-core/WebFormsJS
+
+The npm package is also available:
+
+https://www.npmjs.com/package/webformsjs
+
+Install using npm:
+
+```bash
+npm install webformsjs
+```
 
 ## Development
 
@@ -199,7 +396,7 @@ gem install ./wfc-*.gem
 
 ## Source Code
 
-The WebForms Core source code is available in the [WebForms Core classes repository](https://github.com/webforms-core/Web_forms_classes).
+The WebForms Core source code is available in the [WebForms Core classes repository](https://github.com/webforms-core/WebFormsClasses).
 
 ## License
 

data/lib/web_forms.rb

@@ -1,5 +1,5 @@
-# web_forms.rb 2.1 - The Back-End Part of WebForms Core Technology, Owned by Elanat (https://elanat.net)
-# Compatible with WebFormsJS version 2.1
+# web_forms.rb 2.2 - The Back-End Part of WebForms Core Technology, Owned by Elanat (https://elanat.net)
+# Compatible with WebFormsJS version 2.2
 
 module WebFormsCore
   class WebForms
@@ -269,6 +269,10 @@ module WebFormsCore
       add("ki" + input_place, index.to_s + GS + (checked ? "1" : "0"))
     end
 
+	def set_custom_validity(input_place, text)
+	  add("cv" + input_place, text.gsub("\n", "$[ln];"))
+	end
+
     # Insert
     # Creates the Data only if it does not exist; otherwise, does nothing.
     def insert_id(input_place, id)
@@ -380,16 +384,16 @@ module WebFormsCore
       add("dp" + input_place)
     end
 
-    # Tag
+    # Tag Transformation
     def swap_tag(input_place, output_place)
       add("sp" + input_place, output_place)
     end
 
-    def set_reflection(input_place, tag)
+    def set_reflect(input_place, tag)
       add("sR" + input_place, tag)
     end
 
-    def set_reflection_by_output_place(input_place, output_place)
+    def set_reflect_by_output_place(input_place, output_place)
       add("iR" + input_place, output_place)
     end
 
@@ -401,6 +405,14 @@ module WebFormsCore
       add("iM" + input_place, output_place)
     end
 
+	def snapshot(input_place, key = "", permanent = false)
+	  add("rS" + input_place, ((key.nil? || key.empty?) ? input_place : key) + (permanent ? GS + "1" : ""))
+	end
+
+	def rollback(input_place, key = "", permanent = false)
+	  add("rB" + input_place, ((key.nil? || key.empty?) ? input_place : key) + (permanent ? GS + "1" : ""))
+	end
+
     # Browser
     def change_url(url)
       add("cu", url)
@@ -933,6 +945,18 @@ module WebFormsCore
       add("Dc", pause ? "1" : "0")
     end
 
+	def try_
+	  add("tr")
+	end
+
+	def catch_
+	  add("ca")
+	end
+
+	def comment(text)
+	  add("//", text)
+	end
+
     # Service Worker
     # To Use Service Worker, You Need To Add The Elanat Dedicated Module (service-worker.js) On The Client Side
     def service_worker_register(path = nil, scope_path = nil)
@@ -1023,6 +1047,10 @@ module WebFormsCore
       add("DS", "*")
     end
 
+	def lock_queue(millisecond)
+	  add("lq", millisecond.to_s)
+	end
+
     # Cookie
     def set_cookie(key, value, seconds, path = nil)
       add("sC", key + GS + value + GS + seconds.to_s + (!path.nil? && !path.empty? ? GS + path : ""))
@@ -1142,6 +1170,21 @@ module WebFormsCore
       add("SR", cache_key + GS + value.gsub("\n", "$[ln];") + GS + search_value.gsub("\n", "$[ln];"))
     end
 
+	# Is Regex Replace
+	def set_format_save_value(cache_key, regex, replacement)
+	  add("SF", cache_key + GS + regex + GS + replacement.gsub("\n", "$[ln];"))
+	end
+
+	# Operator: +, -, *, /, %, //, **
+	def set_arithmetic_save_value(cache_key, operator, value)
+	  add("SM", cache_key + GS + operator + GS + value.to_s)
+	end
+
+	# Operation: textafter, textafterlast, textbefore, textbeforelast, substring, remove
+	def set_text_operation_save_value(cache_key, operation, value1, value2)
+	  add("ST", cache_key + GS + operation + GS + value1.to_s + GS + value2.to_s)
+	end
+
     # Cache
     def cache_id(input_place, key = ".")
       add("@ci" + input_place, key)
@@ -1259,7 +1302,22 @@ module WebFormsCore
     def replace_cache_value(cache_key, search_value, value)
       add("CR", cache_key + GS + value.gsub("\n", "$[ln];") + GS + search_value.gsub("\n", "$[ln];"))
     end
-	
+
+	# Is Regex Replace
+	def set_format_cache_value(cache_key, regex, replacement)
+	  add("CF", cache_key + GS + regex + GS + replacement.gsub("\n", "$[ln];"))
+	end
+
+	# Operator: +, -, *, /, %, //, **
+	def set_arithmetic_cache_value(cache_key, operator, value)
+	  add("CM", cache_key + GS + operator + GS + value.to_s)
+	end
+
+	# Operation: textafter, textafterlast, textbefore, textbeforelast, substring, remove
+	def set_text_operation_cache_value(cache_key, operation, value1, value2)
+	  add("CT", cache_key + GS + operation + GS + value1.to_s + GS + value2.to_s)
+	end
+
     # Call
     def load_url(input_place, url)
       add("lu" + input_place, url)
@@ -1369,18 +1427,18 @@ module WebFormsCore
     end
 
     # Pre Runner
-    def assign_delay(mili_second, index = -1)
+    def assign_delay(milli_second, index = -1)
       current_line = get_line_by_index(index)
       return if current_line.nil? || current_line.empty?
 
       parts = current_line.split('=', 2)
-      new_name = ":" + mili_second.to_s + ")" + parts[0]
+      new_name = ":" + milli_second.to_s + ")" + parts[0]
       new_value = parts.length > 1 ? parts[1] : ""
 
       update_line_by_index(index, new_name, new_value)
     end
 
-    def assign_delay_change(mili_second, index = -1)
+    def assign_delay_change(milli_second, index = -1)
       current_line = get_line_by_index(index)
       return if current_line.nil? || current_line.empty?
 
@@ -1392,24 +1450,24 @@ module WebFormsCore
         current_name = current_name[(closing_bracket + 1)..-1]
       end
 
-      new_name = ":" + mili_second.to_s + ")" + current_name
+      new_name = ":" + milli_second.to_s + ")" + current_name
       new_value = parts.length > 1 ? parts[1] : ""
 
       update_line_by_index(index, new_name, new_value)
     end
 
-    def assign_interval(mili_second, id = nil, index = -1)
+    def assign_interval(milli_second, id = nil, index = -1)
       current_line = get_line_by_index(index)
       return if current_line.nil? || current_line.empty?
 
       parts = current_line.split('=', 2)
-      new_name = "(" + mili_second.to_s + (!id.nil? && !id.empty? ? "|" + id : "") + ")" + parts[0]
+      new_name = "(" + milli_second.to_s + (!id.nil? && !id.empty? ? "|" + id : "") + ")" + parts[0]
       new_value = parts.length > 1 ? parts[1] : ""
 
       update_line_by_index(index, new_name, new_value)
     end
 
-    def assign_interval_change(mili_second, id = nil, index = -1)
+    def assign_interval_change(milli_second, id = nil, index = -1)
       current_line = get_line_by_index(index)
       return if current_line.nil? || current_line.empty?
 
@@ -1421,7 +1479,7 @@ module WebFormsCore
         current_name = current_name[(closing_bracket + 1)..-1]
       end
 
-      new_name = "(" + mili_second.to_s + (!id.nil? && !id.empty? ? "|" + id : "") + ")" + current_name
+      new_name = "(" + milli_second.to_s + (!id.nil? && !id.empty? ? "|" + id : "") + ")" + current_name
       new_value = parts.length > 1 ? parts[1] : ""
 
       update_line_by_index(index, new_name, new_value)
@@ -1646,13 +1704,11 @@ module WebFormsCore
       self
     end
 
-    # 'break' is a reserved keyword in Ruby, so 'wf_break' is used to preserve API intent without syntax errors.
-    def wf_break
+    def break_
       add(";")
     end
 
-    # 'else' is a reserved keyword in Ruby, so 'wf_else' is used to preserve API intent without syntax errors.
-    def wf_else
+    def else_
       add("}e")
       self
     end
@@ -1665,8 +1721,9 @@ module WebFormsCore
       add("}")
     end
 
+	# High-Level Methods
     # Used Then In Condition And Loop Methods
-    def then_form(new_form = nil, &block)
+    def then_(new_form = nil, &block)
       if block_given?
         new_form = WebForms.new
         yield new_form
@@ -1687,45 +1744,108 @@ module WebFormsCore
       self
     end
 
-    def repeat_form(new_form = nil, repeat = 1, index = nil, &block)
-      if block_given?
-        temp_form = WebForms.new
-        yield temp_form
-        return repeat_form(temp_form, repeat, index)
-      end
+	def repeat(new_form = nil, repeat_count = 1, index = nil, &block)
+	  if block_given?
+		temp_form = WebForms.new
+		yield temp_form
+		return repeat(temp_form, repeat_count, index)
+	  end
 
-      return self if new_form.nil?
+	  return self if new_form.nil?
 
-      if !index.nil?
-        go_to(index)
-        start_index(index)
-      end
+	  if index.nil?
+		body_data = new_form.get_web_forms_data
+		return self if body_data.nil? || body_data.empty?
 
-      body_data = new_form.get_web_forms_data
+		start_line = body_data.split("\n", -1).length * -1
+		append_form(new_form)
+		go_to(start_line, repeat_count - 1)
+	  else
+		go_to(index)
+		start_index(index)
 
-      return self if body_data.nil? || body_data.empty?
+		body_data = new_form.get_web_forms_data
+		return self if body_data.nil? || body_data.empty?
 
-      if index.nil?
-        start_line = body_data.split("\n", -1).length * -1
-        append_form(new_form)
-        go_to(start_line, repeat - 1)
-      else
-        append_form(new_form)
-        go_to(index, repeat - 1)
-      end
+		append_form(new_form)
 
-      self
-    end
+		if index.empty?
+		  index_number = -1
+		  get_web_forms_data.split("\n").each do |x|
+			index_number += 1 if x.start_with?("#")
+		  end
+		  go_to(index_number.to_s, repeat_count - 1)
+		else
+		  go_to(index, repeat_count - 1)
+		end
+	  end
+
+	  self
+	end
+
+	def isole(new_form = nil, input_place = nil, &block)
+	  if block_given?
+		temp_form = WebForms.new
+		yield temp_form
+		return isole(temp_form, input_place)
+	  end
+
+	  return self if new_form.nil?
+
+	  body_data = new_form.get_web_forms_data
+	  return self if body_data.nil? || body_data.empty?
+
+	  form = WebForms.new
+	  form.start_transient_dom(input_place)
+
+	  append_form(form)
+	  new_form.end_transient_dom
+	  append_form(new_form)
+
+	  self
+	end
+
+    # The Render Method is Sensitive to DOM Changes; It is Recommended to Assign a Stable ID to the Selected Element.
+    # This Method Utilizes the Transient DOM; Therefore, When Selecting InputPlaces, You Must Consider the Root of the Selected InputPlace Within the Method.
+	def render(new_form = nil, input_place = nil, key = "", permanent = false, &block)
+	  if block_given?
+		temp_form = WebForms.new
+		yield temp_form
+		return render(temp_form, input_place, key, permanent)
+	  end
+
+	  return self if new_form.nil?
+
+	  body_data = new_form.get_web_forms_data
+	  return self if body_data.nil? || body_data.empty?
+
+	  key = input_place if key.nil? || key.empty?
+
+	  form = WebForms.new
+
+	  form.exist(permanent ? Fetch.cache(key) : Fetch.save(key))
+		form.rollback(input_place, key, permanent)
+	  form.else_
+		form.snapshot(input_place, key, permanent)
+
+	  form.start_transient_dom(input_place)
+
+	  append_form(form)
+	  new_form.end_transient_dom
+	  append_form(new_form)
+
+	  self
+	end
 
     # Async
     # It Supports Brackets and Then
-    def async_action
+    def async_
       add("{(a)")
       self
     end
 
-    def delay(mili_second)
-      add("De", mili_second.to_s)
+    def delay(milli_second)
+      add("De", milli_second.to_s)
     end
 
     # Option
@@ -2104,7 +2224,7 @@ module WebFormsCore
     end
 
     # MethodName: The Method Name May Need to Include the Class Name, Separated by a Period. Example: MyClassName.MyMethodName
-    def self.wasm_method(wasm_language, wasm_url, method_name, args = nil, key = ".")
+    def self.wasm_method(wasm_language, wasm_url, method_name, args = nil)
       return_value = "@wA" + wasm_language + RS + wasm_url + RS + method_name
       if !args.nil? && args.is_a?(Array)
         return_value += (args.length > 0) ? RS + args.join(US) : ""
@@ -2166,7 +2286,7 @@ module WebFormsCore
       return_value
     end
 
-	# Data
+	# Date
 	def self.date_year = "@dy"
 	# Month In JavaScript Is Start From Index 0, Month In WebForms Core Is Start From Index 1
 	def self.date_month = "@dm"
@@ -2262,7 +2382,11 @@ module WebFormsCore
       "@$V" + input_place
     end
 
-    # Save
+	def self.get_tag_hash(input_place)
+	  "@$H" + input_place
+	end
+
+    # Save and Cache
     def self.has_hash(hash_val)
       "@HH" + hash_val
     end
@@ -2431,13 +2555,10 @@ module WebFormsCore
   end
   
   class WasmLanguage
-    # The Suffix "Mediator" Means You Must Call the JavaScript Interface. In Other Cases, the WASM File Should Be Called Directly.
     def self.c = "c"
     def self.cpp = "c"
     def self.rust = "rust"
     def self.c_sharp = "csharp"
-    # .NET WebCIL Container. The "dotnet.js" File Should Be Invoked.
-    def self.c_sharp_mediator = "csharp-m"
     def self.go = "go"
     def self.java = "java"
     def self.assembly_script = "as"
@@ -2633,7 +2754,7 @@ module WebFormsCore
         return value
       end
 
-      self + "?" + value.gsub("|", "$[vb];").gsub("?", "$[qu];")
+      self + "?" + value.gsub("|", "$[vb];").gsub("?", "$[qu];").gsub("=", "$[eq];")
     end
 
     def append_fetch_replace(search_value, value)

data/lib/wfc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wfc
-  VERSION = "2.1.0"
-end
+  VERSION = "2.2.0"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wfc
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Elanat
@@ -10,6 +10,8 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: WebForms Core (WFC) is a server-driven web interface technology for Ruby.
+  It provides the WebForms Commander for generating WebForms Core commands from Ruby
+  server-side applications.
 email:
 - info@elanat.net
 executables: []
@@ -23,12 +25,14 @@ files:
 - lib/wfc.rb
 - lib/wfc/version.rb
 - sig/wfc.rbs
-homepage: https://elanat.net/page_content/web_forms_core
+homepage: https://elanat.net/webforms-core
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://elanat.net/page_content/web_forms_core
-  source_code_uri: https://github.com/webforms-core/Web_forms_classes
+  homepage_uri: https://elanat.net/webforms-core
+  source_code_uri: https://github.com/webforms-core/WebFormsClasses
+  documentation_uri: https://elanat.net/page_content/documentation
+  bug_tracker_uri: https://github.com/webforms-core/WebFormsClasses/issues
 rdoc_options: []
 require_paths:
 - lib
@@ -45,5 +49,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.16
 specification_version: 4
-summary: WebForms Core technology for Ruby.
+summary: WebForms Core (WFC) for Ruby.
 test_files: []