atome 0.5.7.3.6 → 0.5.7.4.2

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

@@ -21,14 +21,6 @@ new({ particle: :remove, category: :property, type: :hash }) do |params|
       data.map do |hash|
         hash.delete(hash.keys[column]) if hash.keys[column]
       end
-      # elsif params[:all]
-      #   apply.each do |applied_atome|
-      #     if  grab(applied_atome).type.to_sym ==  params[:all].to_sym
-      #       puts "!go"
-      #     end
-      #   end
-      # puts "so_good #{params}"
-      # puts "***> #{apply}"
     end
 
     params
@@ -38,7 +30,6 @@ new({ particle: :remove, category: :property, type: :hash }) do |params|
   end
 
 end
-# new({ particle: :remove, category: :property, type: :hash })
 
 new({ post: :remove }) do |params|
   # TODO : we have to rethink the removal of atome and particles (with exception like category) and maybe 'use particle type' to handle removal
@@ -73,7 +64,7 @@ new({ post: :remove }) do |params|
     end
   else
     # the systems send an id we have to remove it from parent too
-    grab(params).attached.delete(id)
+    grab(params).fasten.delete(id)
     grab(params).affect.delete(id)
   end
   params
@@ -86,7 +77,6 @@ end
 new({ particle: :remove_classes, category: :material, type: :boolean }) do |value|
   Universe.classes[value].delete(id)
 end
-# new ({ particle: :opacity, category: :material, type: :int })
 
 # vector shape
 new({ particle: :definition, category: :material, type: :string })
@@ -115,7 +105,18 @@ new({ after: :pattern }) do |params|
   end
   params
 end
-# new({ particle: :border, category: :material, type: :int })
 new({ particle: :fill, category: :material, type: :array })
 
 new({ particle: :opacity, category: :material, type: :int })
+
+new({ particle: :exchange }) do |params, &bloc|
+  params.each_key do |part_f|
+    part_to_remove = send(part_f)
+    if part_to_remove.instance_of?(Array)
+      part_to_remove.each do |part_to_r|
+        remove(part_to_r)
+      end
+    end
+    set(params)
+  end
+end

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

@@ -11,29 +11,27 @@ def extract_rgb_alpha(color_string)
 end
 
 new({ particle: :red, category: :property, type: :string }) do
-  # alert :ok
   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
   self
 end
 # FIXME  we have to apply both at post and after to make it work
 # used to refresh all affected atomes
-new({after: :red}) do |params|
-  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
+new({ after: :red }) do |params|
+  a = affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
   a.each do |atome_to_refresh|
-      grab(atome_to_refresh).apply(id)
-    end
+    grab(atome_to_refresh).apply(id)
+  end
   params
 end
 
-
 new({ particle: :green, category: :property, type: :string }) do
   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
   self
 end
 
 # used to refresh all affected atomes
-new({after: :green}) do |params|
-  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
+new({ after: :green }) do |params|
+  a = affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
   a.each do |atome_to_refresh|
     grab(atome_to_refresh).apply(id)
   end
@@ -46,8 +44,8 @@ new({ particle: :blue, category: :property, type: :string }) do
 end
 
 # used to refresh all affected atomes
-new({after: :blue}) do |params|
-  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
+new({ after: :blue }) do |params|
+  a = affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
   a.each do |atome_to_refresh|
     grab(atome_to_refresh).apply(id)
   end
@@ -58,8 +56,8 @@ new({ particle: :alpha, category: :property, type: :string }) do
   self
 end
 # used to refresh all affected atomes
-new({after: :alpha}) do |params|
-  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
+new({ after: :alpha }) do |params|
+  a = affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
   a.each do |atome_to_refresh|
     grab(atome_to_refresh).apply(id)
   end
@@ -70,7 +68,6 @@ new({ particle: :diffusion, category: :property, type: :string }) do
   self
 end
 
-
 new({ particle: :clean, category: :property, type: :boolean }) do |params|
   cell = params[:cell]
   row_nb = cell[0]
@@ -91,6 +88,7 @@ new({ particle: :insert, category: :property, type: :string }) do |params|
     position_to_insert = params[:row]
     data.insert(position_to_insert, {})
   elsif params[:column]
+    #
   end
 
   params
@@ -130,7 +128,7 @@ new({ particle: :sort, category: :property, type: :int }) do |params|
   params
 end
 
-new({particle: :inside, render: false})
+new({ particle: :inside, render: false })
 new({ initialized: :inside }) do |params, &user_proc|
   render(:inside, params, &user_proc)
 end
@@ -142,8 +140,35 @@ new({ particle: :value }) do |val|
   val
 end
 
-new({ particle: :behavior, type: :symbol, category: :property  })
+new({ particle: :behavior, type: :symbol, category: :property })
 
 new({ particle: :orientation, type: :symbol, category: :property })
 
-new({ particle: :align , type: :symbol, category: :property })
+new({ particle: :align, type: :symbol, category: :property })
+
+new({ particle: :actor, store: false }) do |params|
+  @actor ||= {}
+  if params[:remove]
+    params[:remove].each do |atome_id, role|
+      @actor[role].delete(atome_id)
+    end
+  else
+    params.each do |atome_id, role|
+      grab(atome_id).role(role)
+      @actor[role] ||= []
+      @actor[role] << atome_id
+    end
+  end
+end
+
+new({ particle: :role, store: false }) do |params|
+  if params.instance_of? Hash
+    if params.keys[0] == :remove
+      @role.delete(params.values[0])
+    end
+  else
+    @role ||= []
+    @role << params
+  end
+end
+

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

@@ -27,51 +27,6 @@ end
 
 new({ read: :password }) do |params|
   # TODO : check if we have to reactive the lines below
-  # params = Black_matter.password if params.nil?
-  # params[:read][:atome] = Black_matter.password[:read][:atome] unless @authorisations[:write][:atome]
-  # params[:write][:atome] = Black_matter.password[:write][:atome] unless @authorisations[:write][:atome]
 
   params
 end
-
-# def get_all_local_storage_items
-  # Création d'un hash pour stocker les paires clé/valeur de localStorage
-  storage_items = {}
-
-  # Obtention du nombre d'éléments dans le localStorage
-#   storage= JS.global[:localStorage]
-# # storage=storage.to_s
-# storage_array= storage.to_a
-# # alert storage_array.length
-# storage_items={}
-# storage_array.each_with_index do |_i, index|
-#   key = JS.global[:localStorage].key(index)
-#   #
-#   #     # Récupération de la valeur associée à cette clé
-#       value = JS.global[:localStorage].getItem(key)
-#   #
-#   #     # Stockage de la paire clé/valeur dans le hash
-#       storage_items[key] = value
-# end
-# puts storage_items
-
-  # alert Native(storage_length).class
-  # Itération sur tous les éléments de localStorage
-#   (0...storage_length).each do |i|
-#     # Récupération de la clé pour l'élément actuel
-#     key = JS.global[:localStorage].key(i)
-#
-#     # Récupération de la valeur associée à cette clé
-#     value = JS.global[:localStorage].getItem(key)
-#
-#     # Stockage de la paire clé/valeur dans le hash
-#     storage_items[key] = value
-#   end
-#
-#   # Retour du hash contenant toutes les paires clé/valeur de localStorage
-#   storage_items
-# end
-#
-# # Appel de la fonction pour récupérer et afficher le contenu de localStorage
-# all_items = get_all_local_storage_items
-# puts all_items

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

@@ -1,20 +1,29 @@
 # frozen_string_literal: true
+def delete_recursive(atome_id, force=false)
+  return if grab(atome_id).tag && (grab(atome_id).tag[:persistent] || grab(atome_id).tag[:system]) unless force
+
+  parent_id_found = grab(atome_id).attach
+  parent_found = grab(parent_id_found)
+  new_array = parent_found.fasten.dup
+  new_array.delete(atome_id)
+  parent_found.instance_variable_set('@fasten', new_array)
+  grab(atome_id).fasten.each do |atome_id_found|
+    delete_recursive(atome_id_found, force)
+  end
+  grab(atome_id).render(:delete, { :recursive => true })
+  grab(atome_id).touch(:remove)
+  Universe.delete(grab(atome_id).aid)
+end
 
 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, category: :utility, type: :boolean }) do |params|
-#   code_found = @code
-#   instance_exec(params, &code_found) if code_found.is_a?(Proc)
-# end
-
 new({ particle: :run }) 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|
   params.each do |atome_f, value_f|
     if value_f.instance_of?(Hash)
@@ -26,125 +35,79 @@ new({ particle: :target }) do |params|
     end
   end
 end
-
-# new({ particle: :broadcast })
-
-def delete_recursive(atome_id, force = false)
-  return if grab(atome_id).tag && (grab(atome_id).tag[:persistent] || grab(atome_id).tag[:system]) unless force
-
-  parent_id_found = grab(atome_id).attach
-  parent_found = grab(parent_id_found)
-  new_array = parent_found.attached.dup
-  new_array.delete(atome_id)
-  parent_found.instance_variable_set('@attached', new_array)
-  grab(atome_id).attached.each do |atome_id_found|
-    delete_recursive(atome_id_found, force)
-  end
-  grab(atome_id).render(:delete, { :recursive => true })
-  grab(atome_id).touch(:remove)
-  Universe.delete(grab(atome_id).aid)
-end
-
 new({ particle: :delete, category: :utility, type: :boolean, render: false }) do |params|
+  if params == true
 
-  basic_system_object = %i[view eDen black_matter intuition copy atome
-  user_view view_color shape_color
-box_color invisible_color text_color circle_color back_selection
-text_selection nil
-]
-
-  unless basic_system_object.include?(id) || id.nil?
-
-    if params == true
-      # 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.attached.delete(id_found)
-        end
-        @affect&.each do |affected_atome|
-          affected_found = grab(affected_atome)
-          affected_found.apply.delete(id_found)
-          affected_found.refresh
-        end
-
-        # Universe.delete(@aid)
-      end
-    elsif params.instance_of? Hash
+    # 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)
-      if params[:recursive]
-        unless grab(@id).tag && (grab(@id).tag[:persistent] || grab(@id).tag[:system])
-          attached.each do |atttached_atomes|
-            delete_recursive(atttached_atomes)
-          end
-          # touch(:remove)
-          # render(:delete, params)
-          # Universe.delete(@aid)
-        end
-      elsif params[:force]
-        attached.each do |atttached_atomes|
-          # alert "attached : #{attached}"
-          delete_recursive(atttached_atomes, true)
-        end
-        # touch(:remove)
-        # 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
+      # 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])
+      Universe.delete(@aid)
+    end
+  elsif params.instance_of? Hash
+    # if we are on a matrix we delete cells found & group found
+    cells.delete(true)
+    group.delete(true)
+    if params[:recursive]
+      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(:remove)
+        render(:delete, params)
+        Universe.delete(@aid)
       end
+    elsif params[:force]
+      fasten.each do |atttached_atomes|
+        # alert "fasten : #{fasten}"
+        delete_recursive(atttached_atomes, true)
+      end
+      touch(:remove)
+      render(:delete, params)
+      # alert "Universe : #{Universe.atomes[@aid]}"
+      # alert "length = #{Universe.atomes.length}"
+      Universe.delete(@aid)
+      # alert "Universe : #{Universe.atomes.length}"
 
-    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} , #{attached}"
     else
-      send(params, 0) unless params == :id
-    end
-    touch(:remove)
-    drag(false)
-    drop(false)
-    on(false)
-    keyboard(false)
-    resize(:remove)
-    overflow(:remove)
-
-    render(:delete, params)
-    Universe.delete(@aid)
-
-    exclusions = %i[@history @renderers @type @tag @html]
-
-    instance_variables.each do |i_var|
-      unless exclusions.include?(i_var)
-        instance_variable_set(i_var, nil)
+      # 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
 
-    instance_variable_set('@renderers', [])
+  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
-  attached_found = []
-  attached.each do |attached_id_found|
-    attached_found << attached_id_found
+  fasten_found = []
+  fasten.each do |fasten_id_found|
+    fasten_found << fasten_id_found
   end
-  attached_found.each do |child_id_found|
+  fasten_found.each do |child_id_found|
     child_found = grab(child_id_found)
     # we exclude system  objects
     child_found&.delete(true) unless child_found.tag && child_found.tag[:system]
@@ -159,9 +122,7 @@ new({ particle: :schedule, category: :utility, type: :string }) do |date, proc|
     send("#{renderer}_schedule", format_date, &proc)
   end
 end
-
 new({ particle: :cursor, category: :utility, type: :string })
-
 new({ particle: :preset, category: :utility, type: :string }) do |params|
 
   if params.instance_of? Hash
@@ -182,7 +143,6 @@ end
 new({ particle: :relations, category: :utility, type: :hash })
 new({ particle: :tag, render: false, category: :utility, type: :hash })
 new({ particle: :web, category: :utility, type: :string })
-# new({ particle: :metrics, type: :hash })
 # do not change the line below initialise is a special method
 new({ initialize: :unit, value: {} })
 new({ particle: :unit, store: false, type: :string, category: :utility }) do |params|
@@ -204,37 +164,33 @@ new({ particle: :browse, category: :utility, type: :string })
 new({ particle: :copies, category: :utility, type: :string })
 new({ particle: :temporary, category: :utility, type: :int })
 new({ particle: :atomes, category: :utility, type: :string })
-
 new({ particle: :match, category: :utility, type: :string }) do |params, _bloc|
   params
 end
-
 new({ sanitizer: :match }) do |params, _bloc|
   params[:condition] = { min: { width: 0 } } unless params[:condition]
   params
 end
-
 new({ particle: :invert, category: :utility, type: :boolean })
 new({ particle: :option, category: :utility, type: :string })
-
 new({ particle: :duplicate, category: :utility, type: :string, store: false }) do |params|
   copy_number = if @duplicate
                   @duplicate.length
                 else
                   0
                 end
-  attached_atomes = []
-  attached_found = attached.dup
-  attached_found.each do |child_id_found|
+  fasten_atomes = []
+  fasten_found = fasten.dup
+  fasten_found.each do |child_id_found|
     child_found = grab(child_id_found)
     if child_found
       new_child = child_found.duplicate({})
-      attached_atomes << new_child.id
+      fasten_atomes << new_child.id
     end
   end
-  params[:attached] = attached_atomes
+  params[:fasten] = fasten_atomes
   infos_found = infos.dup
-  keys_to_delete = %i[history callback duplicate copy paste touch_code html attached aid]
+  keys_to_delete = %i[history callback duplicate copy paste touch_code html fasten aid]
   keys_to_delete.each { |key| infos_found.delete(key) }
   new_atome_id = "#{@id}_copy_#{copy_number}".to_sym
   infos_found[:id] = new_atome_id
@@ -245,16 +201,13 @@ new({ particle: :duplicate, category: :utility, type: :string, store: false }) d
   new_atome
 
 end
-
 new({ after: :duplicate }) do |params|
   @duplicate[@duplicate.keys[@duplicate.keys.length - 1]]
 end
-
 new({ particle: :copy, category: :utility, type: :string }) do |items_id|
   items_id = [items_id] unless items_id.instance_of? Array
   grab(:copy).collect << items_id
 end
-
 new({ particle: :paste, category: :utility, type: :string }) do |params|
 
   all_copies = grab(:copy).collect
@@ -280,37 +233,28 @@ new({ particle: :paste, category: :utility, type: :string }) do |params|
   end
   new_atomes
 end
-
 new({ read: :paste }) do |p|
   @copy
 end
-
 new({ particle: :backup, category: :utility, type: :string })
-
 new({ particle: :import, category: :utility, type: :string })
-
 new({ particle: :compute, category: :utility, type: :string }) do |params|
   params = { particle: params } unless params.instance_of?(Hash)
   params[:unit] ||= :pixel
   params[:reference] ||= :view
   params
 end
-
 new({ particle: :get, category: :utility, type: :string }) do |params|
   cell = params[:cell]
   row_nb = cell[0]
   column_nb = cell[1]
   data[row_nb][data[row_nb].keys[column_nb]] # we get the content of the cell
 end
-
 new({ particle: :css, category: :utility, type: :string })
-
 new({ read: :css }) do
   CssProxy.new(js, nil, self)
 end
-
 new({ particle: :holder, category: :utility, type: :atome })
-
 # this particle is mainly used in conjunction with alternate particle as a 'lambda' to alternate  methods
 new({ particle: :executor, category: :utility, type: :hash }) do |params|
   params.each do |method, opt|
@@ -318,16 +262,12 @@ new({ particle: :executor, category: :utility, type: :hash }) do |params|
   end
   params
 end
-
 new({ particle: :tick, category: :utility, store: false, type: :hash }) do |val|
   @tick[val] ||= 0
   @tick[val] = @tick[val] += 1
   @tick[val]
 end
-
 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 })
-

data/lib/atome/genesis/sparkle.rb

@@ -92,7 +92,6 @@ Atome.new({ renderers: default_render, id: machine_id, type: :machine, password:
 # user
 user_password = { global: :star_win, read: { atome: :star_wars }, write: { atome: :star_wars } }
 
-# human({ id: :anonymous, login: true, password: user_password, data: { birthday: '10/05/1996' }, selection: [], attach: :user_view })
 human({ id: identity_generator, login: true, password: user_password, data: { birthday: '10/05/1996' }, selection: [], attach: :user_view })
 
 Universe.current_machine = machine_id
@@ -161,14 +160,8 @@ def init_database
   A.sync({ action: :init_db, data: { database: :eDen } }) do |data|
     Universe.database_ready = data[:data][:message] == 'database_ready'
   end
-  # authentication : email, pass
-  # atome : date, particles
-  # history : aid, particle, value, date
-
-  particles = Universe.particle_list
   # now we populate the DB
   A.sync({ action: :create_db_table, data: { table: :user, type: :string } }) do |_db_state|
-    # puts "===> #{_db_state}"
   end
   A.sync({ action: :create_db_table, data: { table: :atome } }) do |_db_state|
   end
@@ -191,13 +184,11 @@ def init_database
 
 
   # now we send localstorage content to the server
-  puts "sending localstorage"
   Atome.send_localstorage_content
 
 end
 
 def user_login
-  # user = Universe.current_user
   password = Black_matter.password
   sync({ action: :authentication, data: { email: 'jeezs@atome.one' } }) do |email|
     puts "email received : #{email}"
@@ -212,6 +203,6 @@ end
 # Universe.allow_sync= false # to stop data to be sync on server
 touch_allow(false) # this lock the system right click in web view
 # add a few default font
-# A.add_text_visual({ path: 'Roboto', name: 'Roboto-Bold' })
-# A.add_text_visual({ path: 'Roboto', name: 'Roboto-Thin' })
-# A.add_text_visual({ path: 'Roboto', name: 'Roboto-LightItalic' })
+A.add_text_visual({ path: 'Roboto', name: 'Roboto-Bold' })
+A.add_text_visual({ path: 'Roboto', name: 'Roboto-Thin' })
+A.add_text_visual({ path: 'Roboto', name: 'Roboto-LightItalic' })

data/lib/atome/kernel/black_matter.rb

@@ -1,6 +1,8 @@
+
 class Black_matter
   class << self
     def encode(string)
+      string=string.to_s
       JS.global.sha256(string.to_s)
     end