atome 0.5.7.3.6 → 0.5.7.4.2

data/lib/atome/extensions/atome.rb

@@ -42,31 +42,15 @@ module ObjectExtension
       end
       render_method = "#{renderer_found}_#{params[:specific]}#{params[:method]}"
       Genesis.build_render(render_method, &bloc)
-      # elsif params.key?(:callback)
-      #   particle_targetted = params[:callback]
-      #   Atome.define_method("#{particle_targetted}_callback", option) do
-      #     alert option
-      #     bloc.call(option)
-      #   end
     elsif params.key?(:molecule)
       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)
@@ -75,22 +59,40 @@ module ObjectExtension
       A.build_test(&bloc)
     elsif params.key?(:preset)
       Atome.preset_builder(params[:preset], &bloc)
-      # A.build_test(&bloc)
     end
     super if defined?(super)
   end
 
 end
+
 # atome extensions
 class Object
   include ObjectExtension
+
+  def deep_copy(obj)
+    # utility for buttons
+    case obj
+    when Hash
+      obj.each_with_object({}) do |(k, v), h|
+        unless k == :code # exception to avoid Proc accumulation
+          h[deep_copy(k)] = deep_copy(v)
+        end
+      end
+    when Array
+      obj.map { |e| deep_copy(e) }
+    else
+      obj.dup rescue obj
+    end
+  end
+
   def flash(msg)
-    flash_box=box({width: 235, height: 112})
+    flash_box = box({ width: 235, height: 112 })
     flash_box.text(msg)
     flash_box.touch(true) do
       flash_box.delete({ recursive: true })
     end
   end
+
   def reorder_particles(hash_to_reorder)
     # we reorder the hash
     ordered_keys = %i[renderers id alien type attach int8 unit]
@@ -99,7 +101,6 @@ class Object
     other_part = hash_to_reorder.reject { |k, _| ordered_keys.include?(k) }
     # merge the parts  to obtain an re-ordered hash
     ordered_part.merge(other_part)
-    # reordered_hash
   end
 
   def delete (atomes)
@@ -120,31 +121,9 @@ class Object
     return if id_to_get == false
     aid_to_get = Universe.atomes_ids[id_to_get]
     aid_to_get = '' if aid_to_get.instance_of? Array
-    # id_to_get = id_to_get.to_sym
-
-    # if id_to_get.nil? do
-    # if aid_to_get.nil?
-    #   alert   id_to_get
-    # else
-
-    # end
-    # end
-    # alert Universe.atomes[id_to_get]
     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)
-  # # 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)
     Object.define_method element do |params, &user_proc|
@@ -170,10 +149,6 @@ class Object
     id
   end
 
-  # def repeater(counter, proc)
-  #   instance_exec(counter, &proc) if proc.is_a?(Proc)
-  # end
-
   def repeat_callback(params, counter)
     @repeat[params].call(counter)
   end
@@ -303,7 +278,6 @@ class Object
       end
       console_top.shadow({
                            id: :s1,
-                           # affect: [:the_circle],
                            left: 0, top: 3, blur: 9,
                            invert: false,
                            red: 0, green: 0, blue: 0, alpha: 1
@@ -313,8 +287,6 @@ class Object
         y = console.to_px(:top) + dy.to_f
         console.top(y)
         console.height(:auto)
-        total_height = grab(:view).to_px(:height)
-        # console_back.height(total_height-console.top)
       end
       console_output = console_back.text({ data: '', id: :console_output, component: { size: 12 } })
       JS.eval <<~JS
@@ -328,7 +300,7 @@ class Object
             oldLog.apply(console, arguments);
           };
         }());
-      JS
+JS
 
       console_clear = console_top.circle({ id: :console_clear, color: :red, top: 3, left: 3, width: 19, height: 19 })
       console_clear.touch(true) do
@@ -336,8 +308,6 @@ class Object
       end
       JS.global[:document].addEventListener("contextmenu") do |event|
       end
-      # element[:style][:WebkitUserSelect] = 'none'
-      # element[:style][:MozUserSelect] = 'none'
     else
       grab(:console_back).delete(true)
       JS.global[:document].addEventListener("contextmenu") do |native_event|
@@ -446,7 +416,7 @@ class Object
     ids = []
     dig_recursive = lambda do |atome|
       ids << atome.id
-      atome.attached.each { |attached_atome| dig_recursive.call(grab(attached_atome)) }
+      atome.fasten.each { |fasten_atome| dig_recursive.call(grab(fasten_atome)) }
     end
     dig_recursive.call(self)
     ids
@@ -485,19 +455,13 @@ class Object
         current_atome.height(current_atome.to_px(:height) * ratio)
       end
     end
-    # total_size, max_other_axis_size = calculate_total_size(objet_atome, axis)
-    # scale_factor = target_size.to_f / total_size
-    # resize_and_reposition(objet_atome, scale_factor, axis, max_other_axis_size)
   end
 
   def found_area_used(ids)
-
     min_x, min_y = Float::INFINITY, Float::INFINITY
     max_x, max_y = 0, 0
-
     ids.each do |id|
       atome = grab(id)
-
       x = atome.compute({ particle: :left })[:value]
       y = atome.compute({ particle: :top })[:value]
       width = atome.to_px(:width)
@@ -507,24 +471,19 @@ class Object
       max_x = [max_x, x + width].max
       max_y = [max_y, y + height].max
     end
-
     { min: { x: min_x, y: min_y }, max: { x: max_x, y: max_y } }
-
   end
 
   def calculate_total_size(objet_atome, axis)
     total_size = (axis == :x) ? objet_atome.to_px(:width) : objet_atome.to_px(:height)
     max_other_axis_size = (axis == :x) ? objet_atome.to_px(:height) : objet_atome.to_px(:width)
-
-    objet_atome.attached.each do |child_id|
+    objet_atome.fasten.each do |child_id|
       child = grab(child_id)
       child_size = (axis == :x) ? child.to_px(:width) : child.to_px(:height)
       other_axis_size = (axis == :x) ? child.to_px(:height) : child.to_px(:width)
-
       total_size += child_size
       max_other_axis_size = [max_other_axis_size, other_axis_size].max
     end
-
     [total_size, max_other_axis_size]
   end
 
@@ -532,7 +491,7 @@ class Object
     current_position = 0
     resize_object(objet_atome, scale_factor, axis, max_other_axis_size)
     current_position += (axis == :x) ? objet_atome.to_px(:width) : objet_atome.to_px(:height)
-    objet_atome.attached.each do |child_id|
+    objet_atome.fasten.each do |child_id|
       child = grab(child_id)
       resize_object(child, scale_factor, axis, max_other_axis_size)
       child.top(child.top * scale_factor)
@@ -560,11 +519,11 @@ class Object
       params = { target: params }
     end
     id = params[:id]
-    if id
-      id_wanted = { id: id }
-    else
-      id_wanted = {}
-    end
+    id_wanted = if id
+                  { id: id }
+                else
+                  {}
+                end
     basis = { alien: params[:target], renderers: [:html], type: :atomized }.merge(id_wanted)
     a = Atome.new(basis)
     return a
@@ -573,10 +532,8 @@ class Object
 
   def touch_allow(allow)
     if allow
-      # Retire l'écouteur d'événements en utilisant la fonction globale
       JS.eval('document.removeEventListener("contextmenu", window.preventDefaultAction);')
     else
-      # Ajoute l'écouteur d'événements en utilisant la fonction globale
       JS.eval('document.addEventListener("contextmenu", window.preventDefaultAction);')
     end
   end
@@ -586,13 +543,13 @@ class Object
       # allow selection and text copy
       JS.eval(<<~JS)
         document.body.style.userSelect = 'auto';  // allow text slectiion 
-        document.removeEventListener('copy', preventDefaultAction);  // allow copy 
+        document.removeEventListener('copy', preventDefaultAction);  // allow copy
       JS
     else
       # lock selection and text copy
       JS.eval(<<~JS)
         document.body.style.userSelect = 'none';  // prevent text selection
-        document.addEventListener('copy', preventDefaultAction);  // prevent copy 
+        document.addEventListener('copy', preventDefaultAction);  // prevent copy
       JS
     end
   end
@@ -811,7 +768,4 @@ class CssProxy
     parsed = JSON.parse(msg)
     bloc.call(parsed)
   end
-
 end
-
-

data/lib/atome/extensions/sha.rb

@@ -1,8 +1,8 @@
 # # frozen_string_literal: true
-#
-# # to create a hash
-# class Atome
-#   def calculate_sha(string)
-#     Digest::SHA256.hexdigest(string)
-#   end
-# end
+
+# to create a hash
+class Atome
+  def calculate_sha(string)
+    Digest::SHA256.hexdigest(string)
+  end
+end

data/lib/atome/genesis/atomes.rb

@@ -90,7 +90,7 @@ new({ post: :text }) do |params|
       if index == 0
         send(:data, data_found)
       else
-        # we create new text's atome attached to the main one (the first element above)
+        # we create new text's atome fasten to the main one (the first element above)
         text(data_found)
       end
 

data/lib/atome/genesis/genesis.rb

@@ -22,8 +22,6 @@ class Genesis
       # we add the new method to the particle's collection of methods
       Universe.add_to_particle_list(particle_name, type, category)
       # the line below create an empty particle method for each renderer, eg: browser_left, headless_width, ...
-      # the line below create the corresponding particle method for Batch class
-      # particle_method_for_batch(particle_name)
       auto_render_generator(particle_name) if render
       new_particle(particle_name, store, render, &particle_proc)
       # the line below create all alternatives methods such as create 'method='
@@ -36,11 +34,9 @@ class Genesis
       # the method below generate Atome method creation at Object level,
       # so a syntax like : 'text(:hello)' is possible instead of the mandatory : grab(:view).text(:hello)
       atome_method_for_object(atome_name)
-      # the line below create the corresponding atome method for Batch class
-      # atome_method_for_batch(atome_name)
       unless Essentials.default_params[atome_name]
         # we create default params for the new created atome, adding the hash to : module essential, @default_params
-        # FIXME : the hash : attach: [:view] means that newly atome will systematically be attached to the wview instaed of the parent:
+        # FIXME : the hash : attach: [:view] means that newly atome will systematically be fasten to the wview instaed of the parent:
         # ex : b.www will attach to view not b!
         Essentials.new_default_params(atome_name => { type: atome_name })
       end
@@ -76,9 +72,6 @@ class Genesis
     end
 
     def new_particle(element, store, render, &_method_proc)
-      # unless @id
-      #   alert self.id
-      # end
 
       Atome.define_method element do |params = nil, &user_proc|
         @history[element] ||= []
@@ -87,7 +80,6 @@ class Genesis
           params = particle_sanitizer(element, params, &user_proc)
           # the line below execute the main code when creating a new particle
           # ex : new({ particle: :my_particle } do....
-          # instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
           Genesis.create_particle(element, store, render)
           # TODO: try to optimise and find a better way wo we can remove the condition below
           if @type == :group && !%i[type id collect layout].include?(element)
@@ -98,18 +90,12 @@ class Genesis
 
           computed_params = send("set_#{element}", params, &user_proc) # sent to : create_particle / Atome.define_method "set_#{element}"
 
-          # we historicize all write action below
-          # we add the changes to the stack that must be synchronised
-          # Universe.historicize(@aid, :write, element, params)
           computed_params
         elsif params || params == false
           "send a valid password to write #{element} value"
         elsif read_auth(element)
           # particle getter below
           value_found = instance_variable_get("@#{element}")
-          # uncomment below to  historicize all read action
-          # Universe.historicize(@id, :read, element, value_found)
-          # we add the optional read plugin
           value_found = particle_read(element, value_found, &user_proc)
           value_found
           # TODO : create a fast method to get particle: eg:
@@ -117,9 +103,6 @@ class Genesis
         else
           "send a valid password to read #{element} value"
         end
-        # else
-        #
-        #  end
       end
     end
 
@@ -145,25 +128,18 @@ class Genesis
           # as getter should give us all atome of a given within the atome
           # ex : puts a.shape => return all atome with the type 'shape' in this atome
           collected_atomes = []
-          # attached.each do |attached_atome|
-          #   collected_atomes << attached_atome if grab(attached_atome).type.to_sym == element.to_sym
-          # end
           if Universe.applicable_atomes.include?(element)
-            # we do the same for apply to be able to retrieve 'color' and other atome that apply instead of being attached
-            @apply.each do |attached_atome|
-              collected_atomes << attached_atome if grab(attached_atome).type.to_sym == element.to_sym
+            # we do the same for apply to be able to retrieve 'color' and other atome that apply instead of being fasten
+            @apply.each do |fasten_atome|
+              collected_atomes << fasten_atome if grab(fasten_atome).type.to_sym == element.to_sym
             end
           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
+            fasten.each do |fasten_atome|
+              collected_atomes << fasten_atome if grab(fasten_atome).type.to_sym == element.to_sym
             end
-            # end
 
           end
           # TODO/ FIXME : potential problem with group  here"
-          # group({ collect: collected_atomes })
           collected_atomes
         end
       end
@@ -174,7 +150,6 @@ class Genesis
         # Object.const_set(element, Module.new)
         # we add the newly created atome to the list of "child in it's category, eg if it's a shape we add the new atome
         # to the shape particles list : @!atome[:shape] << params[:id]
-        # Atome.new(params, &user_proc)
 
         if Universe.atomes[params[:id]]
           # if atome id already exist we grab the previous one
@@ -192,75 +167,11 @@ class Genesis
     end
 
     def new_molecule(molecule, &method_proc)
-
       Molecule.define_method molecule do |params, &user_proc|
         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)
-      #   if params
-      #     params = atome_sanitizer(element, params, &user_proc)
-      #     atome_processor(element, params, &user_proc)
-      #   else
-      #     # when no params passed whe assume teh user want a getter,
-      #     # as getter should give us all atome of a given within the atome
-      #     # ex : puts a.shape => return all atome with the type 'shape' in this atome
-      #     collected_atomes = []
-      #     # attached.each do |attached_atome|
-      #     #   collected_atomes << attached_atome if grab(attached_atome).type.to_sym == element.to_sym
-      #     # end
-      #     # TODO : add category for atome( material/physical vs modifier : color, shadow, .. vs shape, image ..)
-      #     # then add condition same things fo code in presets/atome atome_common
-      #     if %i[color shadow paint border].include?(element)
-      #       # we do the same for apply to be able to retrieve 'color' and other atome that apply instead of being attached
-      #       @apply.each do |attached_atome|
-      #         collected_atomes << attached_atome if grab(attached_atome).type.to_sym == element.to_sym
-      #       end
-      #     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
-      #       # end
-      #
-      #     end
-      #     # TODO/ FIXME : potential problem with group  here"
-      #     # group({ collect: collected_atomes })
-      #     collected_atomes
-      #   end
-      # end
-      #
-      # # the method define below is the fastest params are passed directly
-      # Atome.define_method "set_#{element}" do |params, &user_proc|
-      #   # we generate the corresponding module here:
-      #   # Object.const_set(element, Module.new)
-      #   # we add the newly created atome to the list of "child in it's category, eg if it's a shape we add the new atome
-      #   # to the shape particles list : @!atome[:shape] << params[:id]
-      #   # Atome.new(params, &user_proc)
-      #
-      #   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])
-      #     # now we must re-affect affected atomes
-      #     previous_atome.affect(params[:affect])
-      #     previous_atome
-      #   else
-      #     Atome.new(params, &user_proc)
-      #   end
-      #   # Now we return the newly created atome instead of the current atome that is the parent cf: b=box; c=b.circle
-      # end
-
     end
-
   end
 
 end

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

@@ -28,7 +28,7 @@ new({ particle: :language, category: :communication, type: :string }) do |params
   @data = int8[params]
   params
 end
-# method below are used for communication with ntaive core
+# method below are used for communication with native core
 def receptor(msg)
   parsed = JSON.parse(msg)
   A.controller_code[:controller].call(parsed)

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

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 class Atome
   def animation_callback(proc_sub_category, value=nil)
-    # puts  "#{p◊roc_sub_category}"
     proc_found = @animate_code[proc_sub_category]
-    # puts proc_found
     instance_exec(value,&proc_found) if proc_found.is_a?(Proc)
   end
 end
@@ -371,9 +369,3 @@ end
 new({ after: :animate }) do |params|
   html.animate(params) unless params[:end] || params[:start]
 end
-
-
-# new({ particle: :repeat, category: :event, type: :boolean })
-# # new({ particle: :sort }) do |_value, sort_proc|
-# #   @sort_proc = sort_proc
-# # end

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

@@ -7,10 +7,9 @@ new({ particle: :size, category: :geometry, type: :int }) do |params|
   params = { value: params } unless params.instance_of? Hash
   params[:recursive] ||= false
   params[:reference] ||= :x
-  params[:target] ||= :self # :all resize atome + attached +distance between  to the value
-  # self: resize the current atome to current value
+  params[:target] ||= :self # :all resize atome + fasten +distance between  to the value
   params[:propagate] ||= :raw # proportional atome children will be resize according
-  # to its parent , raw apply the raw value to the attached atomes
+  # to its parent , raw apply the raw value to the fasten atomes
   if params[:reference] == :x
     original_width = width
     width(params[:value])
@@ -22,7 +21,7 @@ new({ particle: :size, category: :geometry, type: :int }) do |params|
   end
 
   if params[:recursive]
-    attached.each do |atome_id|
+    fasten.each do |atome_id|
       grab(atome_id).size(params)
     end
 

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

@@ -3,26 +3,19 @@ def detach_child(child)
   return unless child.attach
 
   parent = grab(child.attach)
-  parent.attached.delete(@id)
+  parent.fasten.delete(@id)
 
 end
 
-# def detach_from_parent(parent_found, child_found)
-#   child_found.attach(parent_found.id)
-# end
-
 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)
     end
   else
     child_found = grab(child_id)
@@ -36,19 +29,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 +103,4 @@ 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: :collect, category: :hierarchy, type: :string })

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

@@ -7,41 +7,11 @@ new({ sanitizer: :id }) do |params|
   # first we sanitize the the id below
 
   params = params.to_sym
-  # we check id is already assign
-  # the condition below is to prevent the creation of multiple unwanted colors with same property and no ID specified
-  #   if @id.to_sym != params
-  #     Universe.update_atome_id(params, self, @id)
-  #   else
-  #     Universe.add_to_atomes(params, self)
-  #   end
-
-  # Universe.atomes.each do |_aid,atome_f|
-  #
-  #   if atome_f.id == params
-  #     puts  "===> no for #{params}"
-  #   end
-  #
-  # end
 
   params
 end
 new({ particle: :name, category: :identity, type: :string })
 new({ particle: :active, category: :identity, type: :boolean })
-# new({ particle: :entangled, type: :array })
-# new({ particle: :clones }) do |clones_found|
-#   clones_found.each_with_index do |clone_found, index|
-#     particles_entangled = clone_found[:entangled] ||= []
-#     clone_id = "#{particles[:id]}_clone_#{index}"
-#     original_id = atome[:id]
-#     clone_found[:id] = clone_id
-#     clone_found = particles.merge(clone_found)
-#     clone_found.delete(:html_object)
-#     cloned_atome = Atome.new(clone_found)
-#     monitor({ atomes: [original_id], particles: particles_entangled }) do |_atome, particle, value|
-#       cloned_atome.send(particle, value)
-#     end
-#   end
-# end
 new({ particle: :markup, category: :identity, type: :string })
 new({ particle: :bundle, category: :identity, type: :string })
 new({ particle: :data, category: :identity, type: :string })