atome 0.5.7.0.3 → 0.3191

data/documentation/deep learning/misc.txt

@@ -1,24 +0,0 @@
-Important, please note that almost all requests for JavaScript code will have to be translated into Ruby Wasm, which is the common denominator between Opal and Ruby Wasm. This is because any code written for Ruby Wasm will work with Opal, whereas the reverse is not true. For example, a code with backticks will not work. Can you take this into account each time you are asked for code?
-
-The most important thing is to never use backticks for interpreting JavaScript code in a Ruby environment; instead, use JS.eval.
-
-please ask me some question for you to better understand atome? one question at a time please
-
-
-je viens de te communiquer un fichier zip nommé atome peux tu analyser et le faire un retour , jai supprimé quelques fichier trop volumineux qui sont juste des fichiers sources nécessaires a construction dune application native ou les sources Wasm mais ces fichiers sont aucune incidence sur la façon de programmer ou utiliser atome
-oui il faut que tu analyse plus en datives et surtout lire et comprendre le code contenue dans les fichiers en particuliers la partie du code la plus importante est dans lib , le dossier examples est lui aussi important car il montre  comment les utilisateurs peuvent se servir d'atome
-
-note que example est dans vendor/assets/application/examples
-
-
-
-lorsqu'une personne se designe comme utilisateurs ou si tu pense qu'elle est plus utilisateur que que devellopeur , tu devras lui fournir un code calqué sur le code trouvé dans les exemples , ici : vendor/assets/application/examples
-lorsqu'une personne se designe comme devellopeur ou si tu pense qu'elle est plus devellopeur que qu'utilisateur decars trouver des solutions similaire a ce que l'on trouve dans le dossier lib/atome/genesis/generators
-
-as tu remarqué que le core du framework fait appel a beaucoup de meta programmation est ce que cela ne te gene pas pour comprendre le core d'atome? la grosse partie comprenant de la meta programmation se trouve dans lib/atome.atome.rb et dans lib/atome/helpers/utilities.rb et aussi lib/atome/genesis/genesis.rb
-
-please this is important to note that within the HTML class @element is a js object,  @id is both the id of the atome and the id of the html object
-finally @original_atome is used to acces the atome from the HTML class
-
-Q: What are some common types of projects or applications that users typically create using Atome?
-A: anything , the aim is to replace a ful operating system and all applications possible its a productivity booster, it's aim is to make any task easier and more consistent tan actual solution , without having to deal with computing problems such as file format , format conversion storage , remove all computer (non human ) related concepts such as file extension, conversion , file transfer, ..

data/documentation/deep learning/ruby_js_example.rb

@@ -1,272 +0,0 @@
-# In the context of the Atome framework, when you provide code, debug, or give examples, in fact, whenever there are comments in the code, please always write these comments in English.
-
-# here how to use a callback between ruby and javascript with binding and unbinding :
-
-# example with the over method
-# the method below add an event listener and trig the code found in the @original_atome.over_code[:enter]
-def over_enter(_option)
-  @over_enter = @original_atome.instance_variable_get('@over_code')[:enter]
-  return unless @over_enter
-  @over_enter_callback = lambda do |event|
-    @original_atome.instance_exec(event, &@over_enter) if @over_enter.is_a? Proc
-  end
-  @element.addEventListener('mouseenter', @over_enter_callback)
-
-end
-
-# you can unbind using the method below
-def remove_over_enter(_option)
-  return unless @over_enter_callback
-  # Remove the event listener using the same lambda
-  @element.removeEventListener('mouseenter', @over_enter_callback)
-  @over_enter_callback = nil
-  @over_enter = nil
-
-end
-
-# please note that in the HTML class instance @element is always the current HTML object and is always define
-# You forget every time - one should never suggest using backticks to interpolate JS code. How can you integrate this?
-
-# Here is how to use direct JavaScript methods in a Ruby environment:
-
-# Remember that you can use a variety of JavaScript methods without resorting to eval. For instance, for an EventListener:
-
-@element.addEventListener('mouseleave', lambda do |event|
-  @original_atome.instance_exec('my_params', &@over_leave) if @over_leave.is_a?(Proc)
-end)
-# Or for appending a child:
-
-def append_to(parent_id_found)
-  parent_found = JS.global[:document].getElementById(parent_id_found.to_s)
-  parent_found.appendChild(@element)
-  self
-end
-
-# These examples demonstrate the integration of JavaScript functionality in a Ruby environment,
-# allowing for the use of JavaScript methods and events directly.
-
-# Here is an example of a callback when used with the over particle:
-
-def over_leave(_option)
-  @over_leave = @original_atome.over_code[:leave]
-  @element.addEventListener('mouseleave', lambda do |event|
-    @original_atome.instance_exec(event, &@over_leave) if @over_leave.is_a?(Proc)
-  end)
-end
-
-# This is also important because callbacks are often used. Try to remember this
-
-# Here is a series of examples of basic methods for you to understand how use JavaScript from Ruby
-# this example of callback is true when we have to deal with interoperability between ruby and javascript
-
-class HTML
-
-  def initialize(id_found, current_atome)
-    @element ||= JS.global[:document].getElementById(id_found.to_s)
-    @id = id_found
-    @original_atome = current_atome
-  end
-
-  def attr(attribute, value)
-    @element.setAttribute(attribute.to_s, value.to_s)
-    self
-  end
-
-  def add_class(class_to_add)
-    @element[:classList].add(class_to_add.to_s)
-    self
-  end
-
-  def id(id)
-    attr('id', id)
-    self
-  end
-
-  # to create a html div or H1 or any other tag  the tag is found in the @original_atome.markup instance variable
-  def shape(id)
-    #
-    # we remove any element if the id already exist
-    check_double(id)
-    markup_found = @original_atome.markup || :div
-    @element_type = markup_found.to_s
-    @element = JS.global[:document].createElement(@element_type)
-    JS.global[:document][:body].appendChild(@element)
-    add_class('atome')
-    id(id)
-    self
-  end
-
-  # below here is how to create various html tag
-  def text(id)
-    # we remove any element if the id already exist
-    check_double(id)
-    markup_found = @original_atome.markup || :pre
-    @element_type = markup_found.to_s
-    @element = JS.global[:document].createElement(@element_type)
-    JS.global[:document][:body].appendChild(@element)
-    add_class('atome')
-    id(id)
-    self
-  end
-
-  def image(id)
-    # we remove any element if the id already exist
-    check_double(id)
-    markup_found = @original_atome.markup || :img
-    @element_type = markup_found.to_s
-    @element = JS.global[:document].createElement(@element_type)
-    JS.global[:document][:body].appendChild(@element)
-    add_class('atome')
-    self.id(id)
-    self
-  end
-
-  def video(id)
-    # we remove any element if the id already exist
-    check_double(id)
-    markup_found = @original_atome.markup || :video
-    @element_type = markup_found.to_s
-    @element = JS.global[:document].createElement(@element_type)
-    JS.global[:document][:body].appendChild(@element)
-    add_class('atome')
-    self.id(id)
-    self
-  end
-
-  def www(id)
-    # we remove any element if the id already exist
-    check_double(id)
-    markup_found = @original_atome.markup || :iframe
-    @element_type = markup_found.to_s
-    @element = JS.global[:document].createElement(@element_type)
-    JS.global[:document][:body].appendChild(@element)
-    add_class('atome')
-    @element.setAttribute('src', 'https://www.youtube.com/embed/lLeQZ8Llkso?si=MMsGBEXELy9yBl9R')
-    # below we get image to feed width and height if needed
-    # image = JS.global[:Image].new
-    self.id(id)
-    self
-  end
-
-  def svg(id)
-    # we remove any element if the id already exist
-    check_double(id)
-    markup_found = @original_atome.markup || 'svg'
-    @element_type = markup_found.to_s
-    svg_ns = "http://www.w3.org/2000/svg"
-    @element = JS.global[:document].createElementNS(svg_ns, "svg")
-    JS.global[:document][:body].appendChild(@element)
-    @element.setAttribute('viewBox', '0 0 1024 1024')
-    @element.setAttribute('version', '1.1')
-    add_class('atome')
-    self.id(id)
-    self
-  end
-
-  def svg_data(data)
-    data.each do |type_passed, datas|
-      svg_ns = "http://www.w3.org/2000/svg"
-      new_path = JS.global[:document].createElementNS(svg_ns.to_s, type_passed.to_s)
-      JS.global[:document][:body].appendChild(new_path)
-      datas.each do |property, value|
-        new_path.setAttribute(property.to_s, value.to_s)
-      end
-      @element.appendChild(new_path)
-    end
-  end
-
-  def update_svg_data(data)
-    data.each do |type_passed, datas|
-      element_to_update = JS.global[:document].getElementById(type_passed.to_s)
-      datas.each do |property, value|
-        element_to_update.setAttribute(property.to_s, value.to_s)
-      end
-    end
-  end
-
-  def colorize_svg_data(data)
-    command = <<-JS
-       let svgElement = document.getElementById("#{@id}");
-      if (!svgElement) {
-        return [];
-      }
-      var children = svgElement.children;
-      var ids = [];
-      for (var i = 0; i < children.length; i++) {
-        var element = document.getElementById(children[i].id); // Récupérer l'élément par son ID
-        if (element) {
-            element.setAttribute('fill', '#{data}'); // Modifier l'attribut fill
-            element.setAttribute('stroke', '#{data}'); // Modifier l'attribut stroke
-        }
-        ids.push(children[i].id);
-      }
-  return ids
-    JS
-    JS.eval(command)
-  end
-
-  def raw_data(html_string)
-    @element[:innerHTML] = html_string
-  end
-
-  def video_path(video_path, type = 'video/mp4')
-    source = JS.global[:document].createElement('source')
-    source.setAttribute('src', video_path)
-    source.setAttribute('type', type)
-    @element.appendChild(source)
-  end
-
-  def sanitize_text(text)
-    text.to_s
-        .gsub('&', '&amp;')
-        .gsub('<', '&lt;')
-        .gsub('>', '&gt;')
-        .gsub('"', '&quot;')
-        .gsub("'", '&apos;')
-  end
-
-  def innerText(data)
-    sanitized_data = sanitize_text(data.to_s)
-    @element[:innerText] = sanitized_data
-  end
-
-  def textContent(data)
-    @element[:textContent] = data
-  end
-
-  def path(objet_path)
-    @element.setAttribute('src', objet_path)
-    # below we get image to feed width and height if needed
-    # image = JS.global[:Image].new
-    @element[:src] = objet_path
-    @element[:onload] = lambda do |_event|
-      @element[:width]
-      @element[:height]
-    end
-  end
-
-  def transform(property, value = nil)
-    transform_needed = "#{property}(#{value}deg)"
-    @element[:style][:transform] = transform_needed.to_s
-  end
-
-  def style(property, value = nil)
-    if value
-      @element[:style][property] = value.to_s
-    elsif value.nil?
-      @element[:style][property]
-    else
-      # If value is explicitly set to false, remove the property
-      command = "document.getElementById('#{@id}').style.removeProperty('#{property}')"
-      JS.eval(command)
-    end
-  end
-
-  def filter(property, value)
-    filter_needed = "#{property}(#{value})"
-    @element[:style][:filter] = filter_needed
-  end
-
-end
-
-

data/documentation/deep learning/wasm_script_help.text

@@ -1,14 +0,0 @@
-
-
-curl -LO https://github.com/ruby/ruby.wasm/releases/latest/download/ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz
-tar xfz ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz
-
-
-rm -f ./vendor/assets/src/wasm/ruby/ruby_browser.wasm
-rm -f ./system_ruby_browser.wasm
-mv 3_2-wasm32-unknown-wasi-full-js/usr/local/bin/ruby system_ruby_browser.wasm
-
-wasi-vfs pack system_ruby_browser.wasm --mapdir /lib::./lib/ --mapdir /src::./vendor/assets/src/medias/rubies --mapdir /usr::./3_2-wasm32-unknown-wasi-full-js/usr -o vendor/assets/src/wasm/ruby/ruby_browser.wasm
-cp ./vendor/assets/src/wasm/ruby/ruby_browser.wasm ./test/test_app/src/wasm/ruby/ruby_browser.wasm
-
-

data/documentation/installation/buiding_atome.md

@@ -1,307 +0,0 @@
-<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