atome 0.5.6.8.6 → 0.5.7.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6370fa14baff09e6137332d6c1acb28c9af1471300c1abca20886ed3393b82a0
-  data.tar.gz: de3ecad7c62684abe3f6cb210d819a670d61d2818461856bc05afc03230fd806
+  metadata.gz: '0969d3c09cad0d5f55a4945f77f58615952416ee927c25260c8f02cba5012681'
+  data.tar.gz: 4bf07124488234a077250506c0bf76698f3b0648e557243112489d4787b39141
 SHA512:
-  metadata.gz: 93703fda1d4a8b00dcbf7430bae2bdeacf2530e02e36e5d99c29dc175ac8d10fa4a7c1f5be6b176943f9a834f90bc75b388082c7e85d02b1e26cf579cf311663
-  data.tar.gz: d878ddaf5a47323cc31ad8ddf061ddf15b4c7293e49f5312b0892949f44d7e0094a853be4d6796c5c4689985df0394c73fc679d017709249cc0957634619462b
+  metadata.gz: b6f62fe357b0e0fcde26fca7fe3842f4ac6d66a96dc4ae78f6c129adb402bb37d361f9384d61db635ec8ace5177e97dadc1094f4d875873910863412b6ace81c
+  data.tar.gz: 3e0d1bf658d8567f465616675806743e41704035d861ae3f7e39fb4edca4fb9a53023ffd0d249719d65f9d7a8ff6857773ed2666bc3f54aedbdb6a256d3a26a0

data/documentation/basic.md

@@ -127,7 +127,7 @@ Join us in making multimedia object modeling more efficient, flexible, and power
 
 -
 
-<img src="./documentation/images/3.png" width="666" />
+<img src="../documentation/images/3.png" width="666" />
 
 
 Atome is powerful engine dedicated to the creation of cross-platform applications, web application and digital medias. 
@@ -153,7 +153,6 @@ Cross platform ecosystem
 
 Open source technology included
 -
-
 - Ruby : is the language used to script all atome's apis (https://www.ruby-lang.org)
 
 [comment]: <> (<img src="https://github.com/atomecorp/atome/raw/master/documentation/images/logos/ruby.png" width="100" />)
@@ -182,14 +181,14 @@ Open source technology included
 
 [comment]: <> (<img src="https://avatars.githubusercontent.com/u/54536011?s=200&v=4" width="100" />)
 
-<img src="./documentation/images/logos/ruby.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+<img src="../documentation/images/logos/ruby.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 
-[//]: # (<img src="./documentation/images/logos/cordova.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;)
-<img src="./documentation/images/logos/opal.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
-<img src="./documentation/images/logos/roda.svg" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
-<img src="./documentation/images/logos/freebsd.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
-<img src="./documentation/images/logos/puma.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 
+[//]: # (<img src="./documentation/images/logos/cordova.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;)
+<img src="../documentation/images/logos/opal.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+<img src="../documentation/images/logos/roda.svg" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+<img src="../documentation/images/logos/freebsd.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+<img src="../documentation/images/logos/puma.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 [//]: # (<img src="./documentation/images/logos/tauri.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;)
 
 ## Installation

data/documentation/deep learning/basic_infos.txt

@@ -183,17 +183,17 @@ s.shell_code[:shell]
 
 Callback from javascript :
 In : vendor/assets/src/js/specific/ there’s two methods used to handle callback
-The easier method to send the callback to ruby is to use rubyVMCallback like this :
+The easier method to send the callback to ruby is to use atomeJsToRuby like this :
 
 With javascript you can  call the internal ‘automatically created ‘ method : termninal_callback and send them the data getter from javascript like this :
-rubyVMCallback(‘particle_callback', "('" + js_data + "')")
+atomeJsToRuby(‘particle_callback', "('" + js_data + "')")
 Exemple with terminal particle:
-rubyVMCallback('termninal_callback', "('" + cmd_result + "')")
+atomeJsToRuby('termninal_callback', "('" + cmd_result + "')")
 Or call the callback like this :
-rubyVMCallback( " instance_variable_set(‘@terminal_code’, "’" +data+  "’" )")
-rubyVMCallback("callback(:terminal) ")
+atomeJsToRuby( " instance_variable_set(‘@terminal_code’, "’" +data+  "’" )")
+atomeJsToRuby("callback(:terminal) ")
 
-One is called wasm.js directory and one called opal.js both have the same method  :  rubyVMCallback
+One is called wasm.js directory and one called opal.js both have the same method  :  atomeJsToRuby
 
 On the js side there’s a special method call  ‘callback’ in atome.js file , this method handle all the needed code to create a callback, this method is call like this:
 callback(particle, value)

data/documentation/installation/atome_server.md

@@ -181,4 +181,69 @@ Connect on port 443 with HTTPS to accept wss certificate.
 [comment]: <> (    docker run --name=mediasoup-demo -p 4443:4443/tcp -p 40000-49999:40000-49999/udp -p 40000-49999:40000-49999/tcp -p 3000-3001:3000-3001/tcp --init -v c:/Tmp/mediasoup/certs:/service/certs -e HTTPS_CERT_FULLCHAIN="/service/certs/fullchain.pem" -e HTTPS_CERT_PRIVKEY="/service/certs/privkey.pem" -e MEDIASOUP_ANNOUNCED_IP="192.168.103.92" -e MEDIASOUP_LISTEN_IP="0.0.0.0" mediasoup-demo:v3)
     
     
-[comment]: <> (Wait 10 mn for server starting...)
+[comment]: <> (Wait 10 mn for server starting...)
+
+
+Freebsd mail server install : 
+
+Setting up a mail server on FreeBSD similar to what you might find in cPanel involves multiple components, as cPanel utilizes a software stack that includes mail servers, databases, web servers, and more. For setting up a mail server, you typically need the following components:
+
+- **MTA (Mail Transfer Agent)**: Software for routing and delivering email. Popular choices include Postfix and Exim (used by cPanel).
+- **MDA (Mail Delivery Agent)**: Software for storing and retrieving emails. Dovecot is a common choice.
+- **Webmail**: A web user interface to access emails. RoundCube and Horde are common examples.
+- **Antispam and Antivirus**: SpamAssassin for antispam, ClamAV for antivirus are commonly used options.
+
+Here's a high-level overview to set up a mail server on FreeBSD:
+
+### 1. Update the System
+First, ensure your FreeBSD system is up to date:
+
+```shell
+pkg update && pkg upgrade
+```
+
+### 2. Install Postfix (MTA)
+Install Postfix as the MTA:
+
+```shell
+pkg install postfix
+```
+
+Configure Postfix by editing its configuration file (`/usr/local/etc/postfix/main.cf`). You'll need to set the mail domain, hostname, and other network and security settings.
+
+### 3. Install Dovecot (MDA)
+Install Dovecot to handle email delivery and access:
+
+```shell
+pkg install dovecot
+```
+
+Configure Dovecot by adjusting the configuration files in `/usr/local/etc/dovecot/`. You'll need to set up authentication mechanisms, email storage locations, etc.
+
+### 4. Install Webmail Interface
+Install RoundCube or another webmail client:
+
+```shell
+pkg install roundcube
+```
+
+Configure RoundCube by editing its configuration file, typically located in `/usr/local/www/roundcube/config/`.
+
+### 5. Set Up Antispam and Antivirus
+Install SpamAssassin and ClamAV:
+
+```shell
+pkg install spamassassin clamav
+```
+
+Configure each service to integrate with your MTA and MDA. This may involve editing Postfix and Dovecot's configuration files to include filters and antivirus checks.
+
+### 6. Test Your Configuration
+- Test Postfix by sending emails from the command line.
+- Test Dovecot by logging in via an email client or RoundCube.
+- Ensure SpamAssassin and ClamAV are working by sending test emails that should be marked as spam or contain malicious attachments.
+
+### Important Note:
+Setting up a mail server is complex and involves many aspects, particularly regarding securing and optimizing your server. Make sure to refer to the official documentation of each software and consider security best practices, such as using SSL/TLS, properly setting up DNS records (SPF, DKIM, DMARC), and establishing appropriate access control lists.
+
+This guide provides a very basic overview, and you should refer to the specific FreeBSD, Postfix, Dovecot, RoundCube, SpamAssassin, and ClamAV documentation for detailed instructions and advanced configuration options.

data/documentation/installation/buiding_atome.md

@@ -0,0 +1,307 @@
+<span align="right">
+
+[Main menu](../atome.md)
+-
+</span>
+<span align="left">
+
+[back](./kickstart.md)
+
+</span>
+
+
+Install atome prerequisites
+-
+
+#Install atome (OSX)
+
+IMPORTANT :
+For tauri in prod in "exe/atome" in :
+def build_for_osx(destination).. type:
+
+    `cd #{destination};cargo tauri build`
+for dev type :
+
+    `cd #{destination};cargo tauri dev`
+
+
+Install rust & tauri
+    
+    curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
+    brew install openssl
+    cargo install tauri-cli --force
+
+Install Homebew
+
+    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+
+Install rbenv, wasi-vfs, wasmtime :
+brew install rbenv
+# brew install wasmtime
+=> please check as it is certainly useless because we have in vendor/src-wasm/wasm/wasi_vfs_...,
+if need to install  use :  brew install  wasi-vfs
+
+brew install npm
+npm install --save ruby-3_2-wasm-wasi@latest
+
+Install ruby :
+rbenv install -l
+rbenv install 3.2.2
+
+nano ~/.zshrc => add : eval "$(rbenv init - zsh)"
+rbenv shell  3.2.2
+rbenv global   3.2.2
+gem update --system
+gem update
+
+Get atome gem :
+git clone https://github.com/atomecorp/atome.git
+
+In the terminal at atome root , type:
+bundle install
+Bundle update
+
+Ruby wasm time allow local use of ruby wasm :
+1 - download :
+https://cdn.jsdelivr.net/npm/@ruby/3.2-wasm-wasi@2.3.0/dist/browser.script.iife2.js
+2 - change
+
+
+# how to Install on windows :
+
+# Install ruby :
+https://rubyinstaller.org/downloads install with devkit
+# check install using :
+ruby -v
+gem list
+
+# update gem using the two following commands
+gem update --system
+gem update
+
+#install node:
+https://nodejs.org/en/download
+# check install using :
+node -v
+
+#install wasi :
+npm install --save ruby-3_2-wasm-wasi@latest
+
+#install rust :
+https://www.rust-lang.org/tools/install use rustup
+# check install using :
+rustc --version
+
+
+#install tauri:
+npm install --save-dev @tauri-apps/cli
+# check install using :
+npm fund
+
+#install wasmtime :
+https://wasmtime.dev/
+# check install using :
+ruby wastime --version
+
+#install git :
+https://git-scm.com/
+
+
+# Get atome framework :
+git clone https://github.com/atomecorp/atome.git
+
+# go in the cloned directory the in the terminal at atome root , type:
+bundle install
+Bundle update
+
+# to check we build atome gem
+rake build_gem
+
+# in the terminal type
+gem list
+# check atome is part of the list of the gems
+
+# then in the folder of your choice create a new atome app using :
+atome create my_app
+cd my_app
+atome run browser
+
+
+getter setter for atome are situated in lib/atome/genesis/genesis.rb :     def new_atome(element, &method_proc)
+the getter return a group from the collected atomes ( all included atomes)
+
+
+
+# Third parties's javascript libraries are located at different location
+# If you need to update it or add a JS library you need to clone : https://github.com/atomecorp/atome_third_parties_js.git
+
+The importance of the type :
+
+When a new atome is created the  rendering occurs when it’s type is set : see :  lib/atome/generators/identity.rb
+
+##### rendering a new atome type
+
+Rendering special atomes (color, shadow)that that only affect materials atome(shape, text)
+
+When crating a new atome the first thing the system  is looking at Is ‘type’ so to render, go to identity.rb in your current render folder (ex :html) and create renderer for the current atom type ex :
+new({ method: :type, type: :string, specific: :shape, renderer: :html }) do |_value, _user_proc|
+html.shape(@atome[:id])
+end
+
+
+Paths:
+
+new render here : /Users/jean-ericgodard/Documents/Work/codes/atome/lib/atome/extensions/atome.rb
+class Object
+def new(params, &bloc)
+
+rendering call here: /Users/jean-ericgodard/Documents/Work/codes/atome/lib/renderers/renderer.rb
+
+Automatic renderer generation here: /Users/jean-ericgodard/Documents/Work/codes/atome/lib/atome/extensions/atome.rb :
+class Object
+def new(params, &bloc)
+
+renderers are build here : /Users/jean-ericgodard/Documents/Work/codes/atome/lib/atome/genesis/genesis.rb
+def build_render(renderer_name, &method_proc)
+
+remove condition  /Users/jean-ericgodard/Documents/Work/codes/atome/lib/renderers/renderer.rb in def rendering
+
+New particle example :
+
+new({ particle: :shell })
+# automatically create a @shell instance variable in the atome to store the value
+Usage  :
+
+s=shape({})
+s.shell(‘pwd’)
+s.shape => ‘pwd’
+
+Callback :
+
+
+Important : all atome particle have a pros associated often use for callback when needed :
+to acces this code use "particle_name_code" ex for touch to access the callbacks use : touch_code
+s.shell(‘pwd’) do |method_return|
+puts method_return
+end
+# note that automatically create a @shell_code instance variable in the atome to store proc
+
+Also atome automatically create a call back method suffix with ‘_callback’ ex: shell_callback
+If you call this method the bloc will be executed with the value as parameters
+
+This automatic method could be override using  : new({callback: :shell}) do |params, bloc|
+# …write what you want …
+end
+
+To get the proc you’ll need to use :
+s.shell_code[:shell]
+# please note that s.shell_code return a hash because a single particle may hold many proc (by default the method_code return the default code )
+
+
+
+Callback from javascript :
+In : vendor/assets/src/js/specific/ there’s two methods used to handle callback
+The easier method to send the callback to ruby is to use atomeJsToRuby like this :
+
+With javascript you can  call the internal ‘automatically created ‘ method : termninal_callback and send them the data getter from javascript like this :
+atomeJsToRuby(‘particle_callback', "('" + js_data + "')")
+Exemple with terminal particle:
+atomeJsToRuby('termninal_callback', "('" + cmd_result + "')")
+Or call the callback like this :
+atomeJsToRuby( " instance_variable_set(‘@terminal_code’, "’" +data+  "’" )")
+atomeJsToRuby("callback(:terminal) ")
+
+One is called wasm.js directory and one called opal.js both have the same method  :  atomeJsToRuby
+
+On the js side there’s a special method call  ‘callback’ in atome.js file , this method handle all the needed code to create a callback, this method is call like this:
+callback(particle, value)
+Ex : callback('terminal', ‘cmd’)
+
+
+The power of ‘A’
+# the constant A is used to access any atomes methods without having to create a new atome
+Ex :
+A.monitor({ atomes: [:the_box, :the_cirle], particles: [:left] }) do |atome, particle, value|
+puts "changes : #{atome.id}, #{particle}, #{value}"
+end
+
+to prevent a particle data to be saved you can use :
+
+new ({particle: :build, store: false}) do
+
+# …..
+end
+To save manually you can use the store method , like this :
+
+store({build: :my_data })
+
+The modifier atomes (color, shadow)
+Here is the mechanism of such atome:
+
+
+Important:
+
+Each Each particles and atome is store as an :
+- Particle as an Instant variable in the object itself , get the value of the article simply using : atome.particle
+- Each particle as a hash in the the instance variable @atome within the atome  you can retrieve any particle content using : @atome[:particle]
+- The atome object is also available in html  in the @atome instance variable
+- Atome object is also available in the class Universe within @atomes , to retrieve it use Universe.atomes[atome_id]
+
+It may need a bit more optimization
+
+
+Atomes have a  special method to monitor all attached /affected atomes , call : Atome.global_monitoring
+Code at :  helpers/utilities.rb /def global_monitoring
+Usage :
+Atome.global_monitoring(self, [:red, :blue, :blue, :alpha, :left, :right, :diffusion], [:variable1, :variable2])
+
+The ephemera @new_atome to allow access to data send to the  atome at init time
+
+Important : for atomes that needs to be attached or apply to
+This happen in the method  in presets/atome.rb : atome_common
+at this line :
+if params[:type] == :color || basic_params[:type] == :color || params[:type] == :shadow || basic_params[:type] == :shadow
+
+
+Sanitizer , pre, post , after in atome/helpers/utilities.rb
+
+Sanitizer :
+Particle : allow to modify params send by user before parsing creation  (context is the current atome)
+Atome : allow to modify params send by user before parsing creation
+
+To remove :  in material.b add it to : « new({post: :remove}) do |params| »
+
+
+Pre :
+Particle  : after params parsing and  before rendering  (context is the current atome)
+Atome :  after params parsing and before atome creation  (context is the parent atome)
+
+Post
+Particle  :  after params parsing and  after rendering  (context is the current atome)
+Atome:  after params parsing and  after atome creation (context is the current atome)
+
+After :
+Particle  : only after rendering and storage (context is the current atome)
+
+read:
+To alter a particle before getting the  value
+
+
+
+pay attention to atome category material vs modifier
+color, shadow and paint are modifier
+while shape, image, vector, video audio are materials
+
+there is some specific treatment/code here :
+in presets/atome, atome_common:
+if %i[color shadow paint].include?(atome_preset)
+
+and in genesis,  new_atome :
+:   if %i[color shadow paint].include?(element)
+
+
+
+
+atome expert and atome developers
+expert develop atome core
+developers create solution with atome framework

data/lib/atome/atome.rb

@@ -39,6 +39,7 @@ class Atome
     # @callback = {}
     @tag = {}
     @tick={}
+    @storage={}
     @behavior = {}
     @selected = false
     #@metrics = {}
@@ -47,7 +48,7 @@ class Atome
     @collect = {}
     @int8 = {}
     @css = {}
-    @aid = identity_generator
+    @aid=  new_atome[:aid]  || identity_generator
     @controller_proc=[]
     @id = new_atome[:id] || @aid
     Universe.atomes.each do |_aid,atome_f|
@@ -89,8 +90,6 @@ class Atome
     #     # instance_exec(p_found, &bloc) if bloc.is_a?(Proc)
     #   end
     # end
-
-
   end
 
   def js

data/lib/atome/extensions/atome.rb

@@ -24,7 +24,6 @@ module ObjectExtension
                                                     store: params[:store], type: params[:type],
                                                     category: params[:category] }, &bloc)
       end
-
     elsif params.key?(:sanitizer)
       Genesis.build_sanitizer(params[:sanitizer], &bloc)
     elsif params.key?(:pre)
@@ -55,6 +54,30 @@ module ObjectExtension
       molecule=params[:molecule]
       Genesis.build_molecule(molecule, &bloc)
       Universe.add_to_molecule_list(molecule)
+
+    # elsif params.key?(:applicaton)
+    #   alert params
+
+      # molecule=params[:molecule]
+      # Genesis.build_molecule(molecule, &bloc)
+      # Universe.add_to_molecule_list(molecule)
+    elsif params.key?(:tool)
+      # we only store tools definition in the universe so it can be instanced using "A.build_tool" method when needed
+
+      tool_content = Atome.instance_exec(&bloc) if bloc.is_a?(Proc)
+
+      Universe.tools[params[:tool]]=tool_content
+      # Universe.tools[params[:tool]]=bloc
+
+    elsif params.key?(:template)
+      A.build_template(&bloc)
+    elsif params.key?(:code)
+      A.build_code(&bloc)
+    elsif params.key?(:test)
+      A.build_test(&bloc)
+    elsif params.key?(:preset)
+      Atome.preset_builder(params[:preset], &bloc)
+      # A.build_test(&bloc)
     end
     super if defined?(super)
   end
@@ -137,6 +160,9 @@ class Object
   end
 
   def grab(id_to_get)
+    if id_to_get.instance_of? Atome
+      alert id_to_get.id
+    end
     id_to_get=id_to_get.to_sym
     return if id_to_get == false
     aid_to_get= Universe.atomes_ids[id_to_get]
@@ -156,17 +182,17 @@ class Object
     Universe.atomes[aid_to_get]
   end
 
-  def box(params = {}, &proc)
-    grab(:view).box(params, &proc)
-  end
-
-  # def intuition(params = {}, &proc)
-  #   grab(:view).intuition(params, &proc)
+  # def box(params = {}, &proc)
+  #   grab(:view).box(params, &proc)
+  # end
+  #
+  # # def intuition(params = {}, &proc)
+  # #   grab(:view).intuition(params, &proc)
+  # # end
+  #
+  # def circle(params = {}, &proc)
+  #   grab(:view).circle(params, &proc)
   # end
-
-  def circle(params = {}, &proc)
-    grab(:view).circle(params, &proc)
-  end
 
   # the method below generate Atome method creation at Object level
   def atome_method_for_object(element)
@@ -225,7 +251,7 @@ class Object
            }
 
            function myAction(counter) {
-               rubyVMCallback("repeat_callback(#{repeat_id}, "+counter+")")
+               atomeJsToRuby("repeat_callback(#{repeat_id}, "+counter+")")
            }
 
            const intervalId = repeat(myAction, #{delay} * 1000, #{repeat}); 

data/lib/atome/genesis/atomes.rb

@@ -101,7 +101,7 @@ end
 new({ atome: :machine })
 new({ atome: :paint })
 new({ atome: :vector })
-new({ atome: :matrix })
+new({ atome: :table })
 new({ atome: :atomized, type: :hash })
 
 

data/lib/atome/genesis/genesis.rb

@@ -50,13 +50,11 @@ class Genesis
       new_atome(atome_name, &atome_proc)
 
     end
+
     def build_molecule(molecule_name, &molecule_proc)
       new_molecule(molecule_name, &molecule_proc)
     end
 
-
-
-
     def auto_render_generator(element)
       Universe.renderer_list.each do |render_engine|
         build_render("#{render_engine}_#{element}",)
@@ -164,9 +162,9 @@ class Genesis
           else
             # collected_atomes = attached
             # if @attached
-              attached.each do |attached_atome|
-                collected_atomes << attached_atome if grab(attached_atome).type.to_sym == element.to_sym
-              end
+            attached.each do |attached_atome|
+              collected_atomes << attached_atome if grab(attached_atome).type.to_sym == element.to_sym
+            end
             # end
 
           end
@@ -187,7 +185,7 @@ class Genesis
         if Universe.atomes[params[:id]]
           # if atome id already exist we grab the previous one
           # this prevent the creation of new atome if the atome already exist
-          previous_atome= grab(params[:id])
+          previous_atome = grab(params[:id])
           # now we must re-affect affected atomes
           previous_atome.affect(params[:affect])
           previous_atome
@@ -202,12 +200,14 @@ class Genesis
     def new_molecule(molecule, &method_proc)
 
       Molecule.define_method molecule do |params, &user_proc|
-        m= instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
-        m
+        object_to_return = instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
+        # new_objet = Object.new
+        # # we store the molecule into an instance variable in a basic ruby object
+        # new_objet.instance_variable_set(:@molecule, object_to_return)
+        # new_objet
+        object_to_return
       end
 
-
-
       # # the method define below is the slowest but params are analysed and sanitized
       # Atome.define_method element do |params = nil, &user_proc|
       #   instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)