atome 0.5.7.6.0 → 0.5.7.6.5

data/lib/atome/genesis/particles/utility.rb

@@ -19,12 +19,12 @@ new({ particle: :renderers, category: :utility, type: :string })
 new({ particle: :code, category: :utility, type: :string, store: false }) do |params, code|
   @code[params] = code
 end
-new({ particle: :run }) do |params, code|
+new({ particle: :run, category: :utility, type: :boolean}) do |params, code|
   instance_exec(&params) if params.is_a?(Proc)
   code_found = @code[params]
   instance_exec(params, &code_found) if code_found.is_a?(Proc)
 end
-new({ particle: :target }) do |params|
+new({ particle: :target , category: :utility, type: :string}) do |params|
   params.each do |atome_f, value_f|
     if value_f.instance_of?(Hash)
       value_f.each do |part_f, part_val|
@@ -36,6 +36,80 @@ new({ particle: :target }) do |params|
   end
 end
 new({ particle: :delete, category: :utility, type: :boolean, render: false }) do |params|
+  # if params == true
+  #   touch(false)
+  #   # We use the tag persistent to exclude color of system object and other default colors
+  #   unless @tag && (@tag[:persistent] || @tag[:system])
+  #     # if we are on a matrix we delete cells found & group found
+  #     cells.delete(true)
+  #     group.delete(true)
+  #     # now we detach the atome from it's parent
+  #     # now we init rendering
+  #     render(:delete, params)
+  #     # the machine delete the current atome from the universe
+  #     id_found = @id.to_sym
+  #     if @attach
+  #       parent_found = grab(@attach)
+  #       parent_found.fasten.delete(id_found)
+  #     end
+  #     @affect&.each do |affected_atome|
+  #       affected_found = grab(affected_atome)
+  #       affected_found.apply.delete(id_found)
+  #       affected_found.refresh
+  #     end
+  #     grab(attach).unfasten([id])
+  #     # wait 0.1 do
+  #       Universe.delete(@aid)
+  #     # end
+  #   end
+  # elsif params == false
+  #
+  #
+  #   cells.delete(true)
+  #
+  #   # touch(false)
+  #   # render(:delete, params)
+  #   render(:delete, params)
+  #   Universe.delete(@aid)
+  # elsif params.instance_of? Hash
+  #   # if we are on a matrix we delete cells found & group found
+  #   cells.delete(true)
+  #   group.delete(true)
+  #   touch(false)
+  #   if params[:recursive] == true
+  #     grab(attach).unfasten([id])
+  #     unless grab(@id).tag && (grab(@id).tag[:persistent] || grab(@id).tag[:system])
+  #       fasten.each do |atttached_atomes|
+  #         delete_recursive(atttached_atomes)
+  #       end
+  #       # touch(false)
+  #       # render(:delete, params)
+  #       # html.delete(@id)
+  #       Universe.delete(@aid)
+  #     end
+  #   elsif params[:force]
+  #     fasten.each do |atttached_atomes|
+  #       delete_recursive(atttached_atomes, true)
+  #     end
+  #     touch(false)
+  #     render(:delete, params)
+  #     Universe.delete(@aid)
+  #
+  #   else
+  #     # the machine try to find the sub particle id and remove it eg a.delete(monitor: :my_monitor) remove the monitor
+  #     # with id my_monitor
+  #     params.each do |param, value|
+  #       atome[param][value] = nil
+  #     end
+  #   end
+  #
+  # elsif Universe.atome_list.include?(params)
+  #   # we check if the params passed is an atome to treat it in a different way
+  #   puts "write code here : #{apply} , #{fasten}"
+  # else
+  #   send(params, 0) unless params == :id
+  # end
+
   if params == true
     touch(false)
     # We use the tag persistent to exclude color of system object and other default colors
@@ -43,7 +117,7 @@ new({ particle: :delete, category: :utility, type: :boolean, render: false }) do
       # if we are on a matrix we delete cells found & group found
       cells.delete(true)
       group.delete(true)
-      # now we detach the atome from it's parent
+      # now we detach the atome from its parent
       # now we init rendering
       render(:delete, params)
       # the machine delete the current atome from the universe
@@ -58,19 +132,13 @@ new({ particle: :delete, category: :utility, type: :boolean, render: false }) do
         affected_found.refresh
       end
       grab(attach).unfasten([id])
-      Universe.delete(@aid)
+      delete_with_callback
     end
   elsif params == false
-
-
     cells.delete(true)
-
-    # touch(false)
-    # render(:delete, params)
     render(:delete, params)
-    Universe.delete(@aid)
+    delete_with_callback
   elsif params.instance_of? Hash
-    # if we are on a matrix we delete cells found & group found
     cells.delete(true)
     group.delete(true)
     touch(false)
@@ -80,34 +148,32 @@ new({ particle: :delete, category: :utility, type: :boolean, render: false }) do
         fasten.each do |atttached_atomes|
           delete_recursive(atttached_atomes)
         end
-        # touch(false)
-        # render(:delete, params)
-        # html.delete(@id)
-        Universe.delete(@aid)
+        delete_with_callback do
+          puts "Atome #{@id} supprimé de manière récursive"
+        end
       end
     elsif params[:force]
       fasten.each do |atttached_atomes|
-        # alert "fasten : #{fasten}"
         delete_recursive(atttached_atomes, true)
       end
       touch(false)
       render(:delete, params)
-      Universe.delete(@aid)
-
+      delete_with_callback do
+        puts "Atome #{@id} supprimé avec force"
+      end
     else
-      # the machine try to find the sub particle id and remove it eg a.delete(monitor: :my_monitor) remove the monitor
-      # with id my_monitor
       params.each do |param, value|
         atome[param][value] = nil
       end
     end
-
   elsif Universe.atome_list.include?(params)
-    # we check if the params passed is an atome to treat it in a different way
     puts "write code here : #{apply} , #{fasten}"
   else
     send(params, 0) unless params == :id
   end
+
+
+
 end
 new({ particle: :clear, category: :utility, type: :boolean })
 new({ post: :clear }) do
@@ -168,6 +234,8 @@ new({ particle: :hypertext, category: :utility, type: :string })
 new({ particle: :hyperedit, category: :utility, type: :string })
 new({ particle: :terminal, category: :utility, type: :string })
 new({ particle: :read, category: :utility, type: :string })
+new({ particle: :write, category: :utility, type: :hash })
+new({ particle: :content, category: :utility, type: :string })
 new({ particle: :browse, category: :utility, type: :string })
 new({ particle: :copies, category: :utility, type: :string })
 new({ particle: :temporary, category: :utility, type: :int })
@@ -279,4 +347,4 @@ new({ particle: :storage, category: :utility, type: :hash })
 new({ particle: :state, category: :utility, type: :symbol })
 new({ particle: :record, category: :utility, type: :hash })
 new({ particle: :preview, category: :utility, type: :hash })
-new({particle: :meteo})
+new({particle: :meteo, category: :utility, type: :string})

data/lib/atome/kernel/universe.rb

@@ -27,8 +27,8 @@ class Universe
   @tools = {}
   @allow_tool_operations = false
   @active_tools = []
-  @atome_preset = []
-  @translation={}
+  @preset_list = []
+  @translation = {}
   @default_selection_style = { border: { thickness: 1, red: 1, green: 0, blue: 0, alpha: 1, pattern: :dotted } }
   @applicable_atomes = %i[color shadow border paint animation]
   # @historicize=false
@@ -36,7 +36,7 @@ class Universe
     attr_reader :atomes, :atomes_ids, :renderer_list, :molecule_list, :atome_list, :particle_list, :classes, :counter,
                 :atomes_specificities
     attr_accessor :connected, :allow_sync, :allow_localstorage, :database_ready, :edit_mode, :tools, :tools_root,
-                  :allow_tool_operations, :active_tools, :atome_preset, :applicable_atomes, :default_selection_style,
+                  :allow_tool_operations, :active_tools, :preset_list, :applicable_atomes, :default_selection_style,
                   :translation, :language
 
     def messages
@@ -266,5 +266,9 @@ class Universe
     def story
       @history
     end
+
+    def apis
+      "work in progress, take a look at vendor/assets/src/medias/utils/"
+    end
   end
 end

data/lib/atome/presets/atome.rb

@@ -7,12 +7,12 @@
 
 # additional Atome methods
 class Atome
-  def atome_common(atome_preset, params)
+  def atome_common(preset_list, params)
 
     basic_params = { renderers: [] }
-    # TODO : remove Essentials.default_params[atome_preset] || {} as it is
+    # TODO : remove Essentials.default_params[preset_list] || {} as it is
     # applied twice because preset is now a particle
-    preset_params = Essentials.default_params[atome_preset] || {}
+    preset_params = Essentials.default_params[preset_list] || {}
     basic_params[:type] = preset_params[:type] || :element
     basic_params[:id] = params[:id] || identity_generator
     basic_params[:renderers] = @renderers || preset_params[:renderers]
@@ -21,7 +21,7 @@ class Atome
     params = reordered_params.merge(params)
     params[:id] = params[:id].to_sym
     # condition to handle color/shadow/paint atomes that shouldn't be attach to view
-    if Universe.applicable_atomes.include?(atome_preset)
+    if Universe.applicable_atomes.include?(preset_list)
       unless params[:affect]
         params[:affect] = if @id == :view
                             [:black_matter]

data/lib/atome/utilities/utilities.rb

@@ -23,6 +23,8 @@ class Atome
     end
 
     def server_receiver(params)
+
+      puts "on est ici : #{params}"
       callback_found = Universe.messages[params[:message_id]]
       callback_found.call(params) if callback_found.is_a? Proc
     end
@@ -43,7 +45,7 @@ class Atome
     # atome builder
     def preset_builder(preset_name, &bloc)
       # Important : previously def box , def circle
-      Universe.atome_preset << preset_name
+      Universe.preset_list << preset_name
       Object.define_method preset_name do |params = {}, &proc|
         grab(:view).send(preset_name, params, &proc)
       end
@@ -209,7 +211,6 @@ class Atome
   end
 
   def blocks(params)
-    # alert 'blocks case'
 
     blocks = params.delete(:blocks)
     distribute = params.delete(:distribute)
@@ -447,26 +448,48 @@ class Atome
   # new({callback: :shell}) do |params, bloc|
   # # write what you want …
   # end
-  def particle_callback(element)
-    Atome.define_method("#{element}_callback") do |return_params|
-      # we test if instance_variable_get("@#{element}_code") is a hash for the can se the particle value is a hash
-      proc_found = if instance_variable_get("@#{element}_code").instance_of? Hash
-                     # Then we get the first item of the hash because the proc is fasten to it
-                     instance_variable_get("@#{element}_code").values.first
-                     # instance_exec(@callback[element], proc_found)if proc_found.is_a? Proc
-                   else
-                     instance_variable_get("@#{element}_code")[element]
-                     # instance_exec(@callback[element], proc_found)if proc_found.is_a? Proc
-                   end
-      # array_of_proc_found.each do |proc_found|
-      proc_found.call(return_params) if proc_found.is_a? Proc
-      # end if array_of_proc_found
-
-      # if array_of_proc_found
-      #   proc_found= array_of_proc_found.shift
-      #   proc_found.call(return_params) if proc_found.is_a? Proc
-      # end
+  # def particle_callback(element=nil)
+  #   if element
+  #     Atome.define_method("#{element}_callback") do |return_params|
+  #       # we test if instance_variable_get("@#{element}_code") is a hash for the can se the particle value is a hash
+  #       proc_found = if instance_variable_get("@#{element}_code").instance_of? Hash
+  #                      # Then we get the first item of the hash because the proc is fasten to it
+  #                      instance_variable_get("@#{element}_code").values.first
+  #                      # instance_exec(@callback[element], proc_found)if proc_found.is_a? Proc
+  #                    else
+  #                      instance_variable_get("@#{element}_code")[element]
+  #                      # instance_exec(@callback[element], proc_found)if proc_found.is_a? Proc
+  #                    end
+  #       # array_of_proc_found.each do |proc_found|
+  #       proc_found.call(return_params) if proc_found.is_a? Proc
+  #       # end if array_of_proc_found
+  #
+  #       # if array_of_proc_found
+  #       #   proc_found= array_of_proc_found.shift
+  #       #   proc_found.call(return_params) if proc_found.is_a? Proc
+  #       # end
+  #
+  #     end
+  #   end
+  #
+  # end
 
+  def particle_callback(element = nil)
+    if element
+      Atome.define_method("#{element}_callback") do |return_params = nil|
+        if return_params
+          proc_found = if instance_variable_get("@#{element}_code").instance_of? Hash
+                         instance_variable_get("@#{element}_code").values.first
+                       else
+                         instance_variable_get("@#{element}_code")[element]
+                       end
+          proc_found.call(return_params) if proc_found.is_a? Proc
+        else
+          puts "Warning: #{element}_callback called without return_params"
+        end
+      end
+    else
+      puts "Warning: particle_callback called without element"
     end
   end
 
@@ -478,11 +501,8 @@ class Atome
   end
 
   def read_ruby_callback(element)
-    puts "dunno what this method is about ?? method call :#{element}"
-    # alert id
-    # puts "2 ===> #{element} !!!"
-    # alert  send("terminal_callback").inspect
-    # alert  send("#{element}_callback")
+    # methode used by tauri when there's acallback
+    send("#{element}_callback")
   end
 
   # this method generate the method accessible for end developers
@@ -500,6 +520,26 @@ class Atome
   # def callback(data)
   #   @callback[data.keys[0]] = data[data.keys[0]]
   # end
+  def delete_with_callback(&callback)
+    check_interval = 0.05 # Intervalle de vérification en secondes
+
+    check_completion = proc do
+      # Vérifie si les opérations de rendu sont terminées (tu peux affiner la condition si nécessaire)
+      operations_completed = true # Supposition : opération immédiate pour l'instant
+
+      if operations_completed
+        # Supprimer l’atome de l’univers
+        Universe.delete(@aid)
+        # callback.call if callback # Appeler le callback s’il est défini
+      else
+        # Relancer la vérification après un délai
+        wait(check_interval) { check_completion.call }
+      end
+    end
+
+    # Démarrer la vérification
+    check_completion.call
+  end
 
   def particles(particles_found = nil)
     if particles_found
@@ -544,7 +584,6 @@ class Atome
   #   #     apply(col)
   #   #   end
   #   # end
-  #   # alert id_found
   #   # grab(attach_found).fasten(id_found)
   #   data(data_found)
   #
@@ -601,7 +640,6 @@ class Atome
   end
 
   # def detach_atome(atome_id_to_detach)
-  #   alert :uuu
   #   atome_to_detach = grab(atome_id_to_detach)
   #   # TODO: remove the condition below and find why it try to detach an atome that doesn't exist
   #   nil unless atome_to_detach
@@ -824,6 +862,167 @@ STRR
     JS.eval("fetchSVGContent('#{svg_path}', '#{target}')")
   end
 
+
+  def determine_action(file_content)
+    default_action = { open: true, execute: false }
+    action = default_action.dup
+
+    if file_content.lines.first =~ /#\s*\{BROWSER:\s*\{(.*?)\}\}/
+      content = $1.split(',').map { |pair| pair.split(':').map(&:strip) }.to_h
+      content.each do |key, value|
+        action[key.to_sym] = value == 'true'
+      end
+    end
+
+    action
+  end
+
+
+  def browser(base_path)
+    @path != ''
+    unless grab(:file_browser)
+      @filer = grab(:intuition).box({ id: :file_browser,
+                                      tag: { system: true },
+                                      drag: true,
+                                      top: 9,
+                                      depth: 1,
+                                      left: 600,
+                                      # right:90,
+                                      width: 120,
+                                      height: 600,
+                                      smooth: 8,
+                                      overflow: :auto,
+                                      apply: %i[inactive_tool_col tool_box_border tool_shade],
+                                    })
+    end
+
+    offset = 0
+    @path = base_path
+
+    @filer.text({
+                  data: 'parent',
+                  color: :white,
+                  cursor: :pointer,
+                  left: 20,
+                  top: 0,
+                  position: :absolute,
+                }).touch(:tap) do
+
+      @filer.clear(true)
+      @path = @path.chomp("/")
+      @path = @path[0, @path.rindex("/")] + "/"
+      browser(@path)
+    end
+
+    # folder creation
+    A.terminal("cd #{base_path}  && ls -d */ 2>/dev/null") do |data|
+      data.each_line do |file|
+        file = file.strip
+        next if file.empty?
+
+        parts = file.split("/")
+
+        parts.each_with_index do |part, index|
+          next if part.empty?
+          @filer.text({
+                        data: part,
+                        color: :white,
+                        cursor: :pointer,
+                        left: index * 20,
+                        top: 33 + offset,
+                        position: :absolute,
+                      }).touch(:tap) do
+
+            @filer.clear(true)
+            new_path = @path + "/#{part}"
+            browser(new_path)
+          end
+
+          offset += 20
+        end
+      end
+    end
+    # files creation
+    v = grab(:view)
+    v.terminal("cd #{base_path}  && ls -p | grep -v /") do |data|
+      data.each_line do |file|
+        file = file.strip
+        next if file.empty?
+
+        parts = file.split("/")
+
+        parts.each_with_index do |part, index|
+          next if part.empty?
+          file_path = "#{base_path}/#{file}"
+          # FIXME check in the code whywe need to do that
+          file_path = file_path.gsub("//", "/")
+          @filer.text({
+                        data: part,
+                        color: :orange,
+                        cursor: :pointer,
+                        left: index * 20,
+                        top: 33 + offset,
+                        position: :absolute
+                      }).touch(:tap) do
+            # touch here
+
+            A.read(file_path) do |file_data|
+
+              actions = determine_action(file_data)
+              if actions[:open] == true
+
+                editor = grab(:intuition).box({
+                                                left: 150,
+                                                depth: 0,
+                                                top: 9,
+                                                width: 399,
+                                                height: 699,
+                                                color: { red: 0.07, green: 0.07, blue: 0.07, alpha: 1.0 },
+                                                overflow: :auto,
+                                                drag: true,
+                                                resize: true,
+                                              })
+
+                # file title :
+                editor.text({ data: @path+'/'+file, top: 0, left: 6, color: :orange })
+                # file close
+                close = editor.circle({ color: :yellowgreen, left: :auto, right: 6, top: 9, width: 15, height: 15 })
+                close.text({ data: :x, top: 0, left: 3, color: :black, position: :absolute })
+                close.touch(:tap) do
+                  editor.delete(true)
+                end
+                # file save
+                save = editor.circle({ color: :orange, left: :auto, right: 33, top: 9, width: 15, height: 15 })
+                save.touch(:tap) do
+                  alert :save_file
+                end
+                # file body :
+                body = editor.text({ top: 39, left: 6, color: :lightgrey, data: file_data, edit: true })
+              end
+
+              # file exec if .rb :
+              if file.end_with?('.rb')
+                exec = editor.circle({ color: :red, left: :auto, right: 66, top: 9, width: 15, height: 15 })
+                exec.touch(:tap) do
+                  grab(:view).clear(true)
+                  grab(:view).instance_eval(body.data)
+                end
+              end
+
+              if actions[:execute] == true
+                grab(:view).clear(true)
+                grab(:view).eval(file_data)
+              end
+              #
+            end
+          end
+
+          offset += 20
+        end
+      end
+    end
+  end
+
 end
 
 

data/lib/atome/version.rb

@@ -3,5 +3,5 @@
 #  return atome version
 
 class Atome
-  VERSION = '0.5.7.6.0'
+  VERSION = '0.5.7.6.5'
 end

data/lib/molecules/intuition/tools.rb

@@ -270,7 +270,7 @@ class Atome
     # now we get the values from selected atomes
     Atome.selection.each do |atome_id_to_treat|
       tool.data[:action]&.each_key do |particle_req|
-        unless Universe.atome_preset
+        unless Universe.preset_list
           value_found = grab(atome_id_to_treat).send(particle_req)
           if value_found
             tool.data[:action][particle_req] = value_found

data/lib/molecules/intuition/utilities.rb

@@ -449,7 +449,6 @@ new({ molecule: :slider }) do |params, bloc|
 
 end
 
-new({ particle: :cells })
 
 new(molecule: :matrix) do |params, &bloc|
   params ||= {}

data/lib/renderers/html/html.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 #  this class is aimed at html rendering
 
 class HTML
@@ -270,10 +269,14 @@ class HTML
   end
 
   def send_message(message)
-    # puts "message : #{message}"
-    # FIXME  : find why we have to sanitize this message when using ruby wams
-    message = transform_to_string_keys_and_values(message)
-    JS.eval("atomeJS.ws_sender('#{message}')")
+    # FIXME  : find why we have to sanitize this message when using ruby W
+
+    if Atome::host == 'pure_wasm'
+      message = transform_to_string_keys_and_values(message)
+    end
+    message_string = JSON.generate(message)
+    js_safe_string = message_string.gsub('"', '\"')
+    JS.eval("atomeJS.ws_sender(\"#{js_safe_string}\")")
   end
 
   def close_websocket
@@ -508,6 +511,18 @@ class HTML
     self
   end
 
+  def draw(id)
+    # we remove any element if the id already exist
+    check_double(id)
+    markup_found = @original_atome.markup || :canvas
+    @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 text(id)
     # we remove any element if the id already exist
     check_double(id)
@@ -1673,19 +1688,62 @@ class HTML
     JS.eval('return navigator.onLine')
   end
 
+
+
   def terminal(id, cmd)
     if Atome.host == 'tauri'
       JS.eval("terminal('#{id}','#{cmd}')")
     else
-      JS.eval("distant_terminal('#{id}','#{cmd}')")
+      # JS.eval("distant_terminal('#{id}','#{cmd}')")
+      A.message({data: cmd, action: :terminal}) do |result|
+        proc_found= @original_atome.terminal_code[:terminal]
+        string_found = result[:data]
+        string_found=string_found.gsub('\x23', '#')
+        converted_string = string_found.gsub(/<<(\w+)\n(.*?)\n\1/m) do
+          marker = $1
+          content = $2
+          "\"#{content.gsub(/\n/, '\\n')}\"" # Escapes newlines for JavaScript compatibility
+        end
+        proc_found.call(converted_string) if proc_found.is_a?(Proc)
+      end
     end
   end
 
+
   def read(id, file)
     if Atome.host == 'tauri'
       JS.eval("readFile('#{id}','#{file}')")
     else
-      puts 'read file in progress in server mode'
+      A.message({data: {source: file,operation: :read  }, action: :file}) do |result|
+        proc_found= @original_atome.instance_variable_get('@read_code')[:read]
+        string_found = JSON.parse(result[:data])
+        string_found=string_found.gsub('\x23', '#')
+        converted_string = string_found.gsub(/<<(\w+)\n(.*?)\n\1/m) do
+          marker = $1
+          content = $2
+          "\"#{content.gsub(/\n/, '\\n')}\"" # Escapes newlines for JavaScript compatibility
+        end
+        proc_found.call(converted_string) if proc_found.is_a?(Proc)
+      end
+    end
+  end
+
+  def write(id, file)
+
+    if Atome.host == 'tauri'
+      JS.eval("writeFile('#{id}','#{file[:name]}','#{file[:content]}')")
+    else
+      A.message({data: {source: file,operation: :write  }, action: :file}) do |result|
+        proc_found= @original_atome.instance_variable_get('@write_code')[:write]
+        string_found = JSON.parse(result[:data])
+        string_found=string_found.gsub('\x23', '#')
+        converted_string = string_found.gsub(/<<(\w+)\n(.*?)\n\1/m) do
+          marker = $1
+          content = $2
+          "\"#{content.gsub(/\n/, '\\n')}\"" # Escapes newlines for JavaScript compatibility
+        end
+        proc_found.call(converted_string) if proc_found.is_a?(Proc)
+      end
     end
   end