atome 0.5.7.3.6 → 0.5.7.3.9

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

@@ -3,7 +3,7 @@ def detach_child(child)
   return unless child.attach
 
   parent = grab(child.attach)
-  parent.attached.delete(@id)
+  parent.fasten.delete(@id)
 
 end
 
@@ -16,13 +16,13 @@ def attachment_common(child_id, parents_id, direction, &user_proc)
   parent_found = grab(parents_id)
   if direction == :attach
     if parent_found
-      parent_found.attached ||= []
-      parent_found.attached.push(@id) unless parent_found.attached.include?(@id)
+      parent_found.fasten ||= []
+      parent_found.fasten.push(@id) unless parent_found.fasten.include?(@id)
       detach_child(self)
       render(:attach, parents_id, &user_proc)
     else
       # we remove the current id  from parent
-      # grab(attach).attached.delete(@id)
+      # grab(attach).fasten.delete(@id)
     end
   else
     child_found = grab(child_id)
@@ -36,19 +36,41 @@ new({ particle: :attach, category: :hierarchy, type: :string, render: false }) d
   parents_id
 end
 
-new({ particle: :attached, category: :hierarchy, type: :string, render: false }) do |children_ids, &user_proc|
+new({ particle: :fasten, category: :hierarchy, type: :string, render: false }) do |children_ids, &user_proc|
   children_ids = [children_ids] unless children_ids.instance_of?(Array)
   parents_id = @id
   children_ids.each do |children_id|
-    attachment_common(children_id, parents_id, :attached, &user_proc)
+    attachment_common(children_id, parents_id, :fasten, &user_proc)
   end
   children_ids
 end
 
-new({ sanitizer: :attached }) do |children_ids|
+new({ sanitizer: :fasten }) do |children_ids|
   children_ids
 end
 
+new({ particle: :unfasten }) do |params|
+  params = fasten if params == :all
+  dup_params = params.dup
+  dup_params.each do |param|
+    if fasten.include?(param)
+      fasten.delete(param)
+      atome_to_unfasten = grab(param)
+      atome_to_unfasten_left = atome_to_unfasten.left
+      atome_to_unfasten_top = atome_to_unfasten.top
+      parent_top = top
+      parent_left = left
+      atome_to_unfasten.attach(:view)
+      atome_to_unfasten.left(atome_to_unfasten_left + parent_left)
+      atome_to_unfasten.top(atome_to_unfasten_top + parent_top)
+    end
+  end
+end
+
+new({ particle: :detach }) do |params|
+  grab(params).unfasten([id])
+end
+
 new({ particle: :apply, category: :hierarchy, type: :string, render: false, store: false }) do |parents_ids, &user_proc|
   @apply ||= []
   parents_ids = [parents_ids] unless parents_ids.instance_of?(Array)
@@ -88,18 +110,31 @@ new({ particle: :affect, category: :hierarchy, type: :string, render: false }) d
   children_ids
 end
 
-new({ particle: :detached, category: :hierarchy, type: :string, store: false }) # unfastened
-new({ sanitizer: :detached }) do |values|
-  # unfastened
-  if values.instance_of? Array
-    values.each do |value|
-      detach_atome(value)
-    end
-  else
-    detach_atome(values)
-    # we sanitize the values so it always return an array to the renderer
-    values = [values]
-  end
-  values
-end
+# new({ particle: :detached, category: :hierarchy, type: :string, store: false }) # unfastened
+# new({ sanitizer: :detached }) do |values|
+#   # unfastened
+#   if values.innew({ particle: :detached, category: :hierarchy, type: :string, store: false }) # unfastened
+# # new({ sanitizer: :detached }) do |values|
+# #   # unfastened
+# #   if values.instance_of? Array
+# #     values.each do |value|
+# #       detach_atome(value)
+# #     end
+# #   else
+# #     detach_atome(values)
+# #     # we sanitize the values so it always return an array to the renderer
+# #     values = [values]
+# #   end
+# #   values
+# # endstance_of? Array
+#     values.each do |value|
+#       detach_atome(value)
+#     end
+#   else
+#     detach_atome(values)
+#     # we sanitize the values so it always return an array to the renderer
+#     values = [values]
+#   end
+#   values
+# end
 new({ particle: :collect, category: :hierarchy, type: :string })

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

@@ -73,7 +73,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
@@ -119,3 +119,15 @@ end
 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

@@ -147,3 +147,30 @@ new({ particle: :behavior, type: :symbol, category: :property  })
 new({ particle: :orientation, 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/utility.rb

@@ -29,15 +29,16 @@ end
 
 # new({ particle: :broadcast })
 
-def delete_recursive(atome_id, force = false)
+
+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 = parent_found.fasten.dup
   new_array.delete(atome_id)
-  parent_found.instance_variable_set('@attached', new_array)
-  grab(atome_id).attached.each do |atome_id_found|
+  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 })
@@ -46,105 +47,206 @@ def delete_recursive(atome_id, force = false)
 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
+      Universe.delete(@aid)
+    end
+    # elsif params == :force
+    #   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
+    #   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)
+    if params[:recursive]
+      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
 
+
+# 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: :delete, category: :utility, type: :boolean, render: false }) do |params|
+#
+#   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.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
+#         # 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]
+#         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)
+#         # 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
+#     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)
+#       end
+#     end
+#
+#     instance_variable_set('@renderers', [])
+#   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]
@@ -223,18 +325,18 @@ new({ particle: :duplicate, category: :utility, type: :string, store: false }) d
                 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
@@ -331,3 +433,9 @@ new({ particle: :state, category: :utility, type: :symbol })
 new({ particle: :record, category: :utility, type: :hash })
 new({ particle: :preview, category: :utility, type: :hash })
 
+# new(particle: :update) do |params| # specific to buttons molecule for now
+#   old_data= data
+#   delete({recursive: true})
+#   new_content=old_data.merge(params)
+#   buttons(new_content)
+# end

data/lib/atome/genesis/sparkle.rb

@@ -191,7 +191,7 @@ def init_database
 
 
   # now we send localstorage content to the server
-  puts "sending localstorage"
+  # puts "sending localstorage"
   Atome.send_localstorage_content
 
 end

data/lib/atome/kernel/black_matter.rb

@@ -1,9 +1,12 @@
+
 class Black_matter
   class << self
     def encode(string)
+      string=string.to_s
       JS.global.sha256(string.to_s)
     end
 
+
     def check_password(input_password, stored_hash)
       input_hash = encode(input_password)
       input_hash == stored_hash

data/lib/atome/utilities/utilities.rb

@@ -327,7 +327,7 @@ class Atome
     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 attached to it
+                     # 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
@@ -430,11 +430,12 @@ class Atome
     end
   end
 
-  def detach_atome(atome_id_to_detach)
-    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
-  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
+  # end
 
   def debug(msg)
     puts msg
@@ -459,8 +460,8 @@ class Atome
     remove({ category: attach })
     category(:atome)
     attach(grand_parent)
-    #  we delete the parent (the layout) if it no more children attached
-    if parent_found.attached.length == 0
+    #  we delete the parent (the layout) if it no more children fasten
+    if parent_found.fasten.length == 0
       parent_found.delete(true)
     end
   end
@@ -503,12 +504,22 @@ class Atome
   #   puts "sanitizer temp patch when an atome is passed instead of an id"
   #   @id
   # end
+  # def transform_to_string_keys_and_values(hash)
+  #   hash.transform_keys(&:to_s).transform_values do |value|
+  #     if value.is_a?(Hash)
+  #       transform_to_string_keys_and_values(value)
+  #     else
+  #       value.to_s
+  #     end
+  #   end
+  # end
 
   def sync(params, &bloc)
     params = { data: params } unless params.instance_of? Hash
     message_id = "msg_#{Universe.messages.length}"
     params[:message_id] = message_id
     Universe.store_messages({ msg_nb: message_id, proc: bloc })
+    # params = transform_to_string_keys_and_values(params)
     html.send_message(params)
   end
 

data/lib/atome/version.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 #  return atome version
+
 class Atome
-  VERSION = '0.5.7.3.6'
+  VERSION = '0.5.7.3.9'
 end