atome 0.5.3.8.1 → 0.5.3.8.8

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

@@ -1,56 +1,99 @@
 # frozen_string_literal: true
 
-new({ particle: :attached })
-new({ sanitizer: :attached }) do |params|
-  params = [params] unless params.instance_of? Array
-  params
+new({ particle: :attach })
+new({ sanitizer: :attach }) do |parents_ids|
+  parents_ids = parents_ids.value if parents_ids.instance_of? Atome
+  parents_ids = [parents_ids] unless parents_ids.instance_of?(Array)
+  parents_ids.each do |parents_id|
+    parents_id = parents_id.value if parents_id.instance_of? Atome
+    parents_found = grab(parents_id)
+    # TODO : factorise the code below
+    current_type = atome[:type]
+    parents_found.atome[current_type] = [] unless parents_found.atome[current_type]
+
+    # the condition below is needed when user passed a hash instead of the id of the child cf :
+    parent_type_container = if parents_found.atome[current_type].instance_of? Array
+                              parents_found.atome[current_type]
+                            else
+                              [parents_found.atome[current_type][:id]]
+                            end
+    # here we add the child into it's parents type container
+    parent_type_container << atome[:id]
+    # TODO : factorise the code above
+    parents_found.atome[:attached] = [] unless parents_found.atome[:attached]
+    parents_found.atome[:attached] << atome[:id]
+  end
+  # atome[:parents]=atome[:parents] | parents_ids
+  # atome[:parents].concat(parents_ids).uni
+  # puts "==> #{id} : #{self}"
+  # puts "====> id : #{id}, #{parents_ids} #{atome[:parents]}, #{atome[:parents].class} : #{atome[:parents].class}"
+  parents_ids
 end
-new({ pre: :attached }) do |children_ids|
+
+new({ particle: :attached })
+new({ sanitizer: :attached }) do |children_ids|
+  children_ids = children_ids.value if children_ids.instance_of? Atome
+  children_ids = [children_ids] unless children_ids.instance_of?(Array)
   children_ids.each do |child_id|
     child_id = child_id.value if child_id.instance_of? Atome
     child_found = grab(child_id)
     parents_found = @atome[:id]
-    child_found.family(parents_found)
+    # TODO : factorise the code below
+    child_found_type = child_found.type.value
+    @atome[child_found_type] = [] unless @atome[child_found_type]
+
+    # the condition below is needed when user passed a hash instead of the id of the child cf :
+    # circle(color: {red: 0, green: 1}) instead of color({id: :the_col}); circle(color: [:the_col])
+    child_type_container = if @atome[child_found_type].instance_of? Array
+                             @atome[child_found_type]
+                           else
+                             [@atome[child_found_type][:id]]
+                           end
+    child_type_container << child_id
+    # TODO : factorise the code above
+
+    # child_found.family(parents_found)
     child_found.atome[:attach] = [parents_found]
   end
 end
-new({ particle: :type })
-new({ particle: :children })
 
-new ({ sanitizer: :children }) do |params|
-  # TODO factorise the line below and 'sanitized_params' for all particle type of Array
-  params = [params] unless params.instance_of? Array
-  sanitized_params = []
-  params.each do |child_id|
-    child_id = child_id.value if child_id.instance_of? Atome
-    sanitized_params << child_id
-    child_found = grab(child_id)
-    parents_found = @atome[:id]
-    # FIXME : broadcast may malfunction because of the commented line below,
-    # FIXME suite : if uncomment object hierarchy is broken (cf Vie Project)
-    # FIXME : parent child problem may be caused by th eline below
-    child_found.family(parents_found)
-    child_found.atome[:parents] = [parents_found]
-  end
-  sanitized_params
-end
+new({ particle: :detached, store: false })
 
-new({ particle: :parents })
-new({ sanitizer: :parents }) do |params|
-  params = [params] unless params.instance_of? Array
-  sanitized_params = []
-  params.each do |parents_id|
-    parents_id = parents_id.value if parents_id.instance_of? Atome
-    sanitized_params << parents_id
-    parents_found = grab(parents_id)
-    family(parents_id)
-    parents_found.atome[:children] << atome[:id]
+new({ sanitizer: :detached }) do |values|
+  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
-  sanitized_params
+  values
 end
 
-new({ particle: :family })
-new({ particle: :link })
+new({ particle: :type })
+
+# new({ particle: :parents })
+# new({ sanitizer: :parents }) do |params|
+#   params = [params] unless params.instance_of? Array
+#   sanitized_params = []
+#   params.each do |parents_id|
+#     parents_id = parents_id.value if parents_id.instance_of? Atome
+#     sanitized_params << parents_id
+#     parents_found = grab(parents_id)
+#     # TODO : factorise the code below
+#     current_type = atome[:type]
+#     parents_found.atome[current_type] = [] unless parents_found.atome[current_type]
+#     parents_found.atome[current_type] << atome[:id]
+#     # TODO : factorise the code above
+#     # TODO : check if we can remove the family
+#     family(parents_id)
+#   end
+#   sanitized_params
+# end
+
+# new({ particle: :family })
 new({ particle: :id })
 new({ sanitizer: :id }) do |params|
   if @atome[:id] != params
@@ -62,19 +105,7 @@ new({ sanitizer: :id }) do |params|
 end
 new({ particle: :name })
 new({ particle: :active })
-new({ particle: :attach })
-new({ pre: :attach }) do |parents_ids|
-  parents_ids.each do |parents_id|
-    parents_id = parents_id.value if parents_id.instance_of? Atome
-    parents_found = grab(parents_id)
-    family(parents_id)
-    parents_found.atome[:attached] = [] unless parents_found.atome[:attached]
-    parents_found.atome[:attached] << atome[:id]
-  end
-end
-new({ particle: :detached }) do |value|
-  attached.value.delete(value)
-end
+
 new({ particle: :intricate, type: :array })
 new({ particle: :clones }) do |clones_found|
   clones_found.each_with_index do |clone_found, index|

data/lib/atome/genesis/generators/spatial.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-new({ particle: :left }) do |_params, user_proc|
+new({ particle: :left, type: :integer }) do |_params, user_proc|
   instance_exec(&user_proc) if user_proc.is_a?(Proc)
 end
-new({ particle: :right })
-new({ particle: :top })
-new({ particle: :bottom })
-new({ particle: :rotate })
-new({ particle: :direction })
-new({ particle: :center })
-new ({particle: :depth})
+new({ particle: :right, type: :integer })
+new({ particle: :top, type: :integer })
+new({ particle: :bottom, type: :integer })
+new({ particle: :rotate, type: :integer })
+new({ particle: :direction, type: :string })
+new({ particle: :center, type: :string})
+new ({particle: :depth, type: :integer})
 

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

@@ -1,19 +1,29 @@
 # frozen_string_literal: true
 
-
-new({particle: :renderers })
-new({particle: :code })
-new({particle: :run }) do |params|
+new({ particle: :renderers })
+new({ particle: :code })
+new({ particle: :run }) do |params|
   code_found = @atome[:code]
   instance_exec(params, &code_found) if code_found.is_a?(Proc)
 end
-new({particle: :broadcast })
-new({particle: :data })
-new({particle: :additional })
-new({particle: :delete }) do |params|
+new({ particle: :broadcast })
+new({ particle: :data })
+# new({particle: :additional })
+new({ particle: :delete }) do |params|
   if params == true
-    # the machine delete the current atome
+    # now we detach the atome from it's parent
+    parents_found = @atome[:attach]
+    parents_found.each do |parent_found|
+      grab(parent_found).detached(@atome[:id])
+    end
+
+    # the machine delete the current atome from the universe
     Universe.delete(@atome[:id])
+  elsif params == :materials
+    # this will delete any child with a visual type cf : images, shapes, videos, ...
+    materials.each do |atome_id_found|
+      grab(atome_id_found).delete(true)
+    end
   elsif params[:id]
     # the machine try to an atome by it's ID and delete it
     grab(params[:id]).delete(true)
@@ -28,9 +38,9 @@ new({particle: :delete }) do |params|
     send(params, 0)
   end
 end
-new({particle: :clear })
-new({particle: :path })
-new({particle: :schedule }) do |date, proc|
+new({ particle: :clear })
+new({ particle: :path })
+new({ particle: :schedule }) do |date, proc|
   date = date.to_s
   delimiters = [',', ' ', ':', '-']
   format_date = date.split(Regexp.union(delimiters))
@@ -38,15 +48,14 @@ new({particle: :schedule }) do |date, proc|
     send("#{renderer}_schedule", format_date, &proc)
   end
 end
-new({particle: :read }) do |file, proc|
+new({ particle: :read }) do |file, proc|
   Universe.renderer_list.each do |renderer|
     send("#{renderer}_reader", file, &proc)
   end
 end
-new({particle: :cursor })
-new({particle: :preset })
-new({particle: :relations,type: :hash  })
-
+new({ particle: :cursor })
+new({ particle: :preset })
+new({ particle: :relations, type: :hash })
 
 # generator = Genesis.generator
 #

data/lib/atome/genesis/genesis.rb

@@ -21,7 +21,7 @@ class Atome
 
     # we add the new method to the particle's collection of methods
     Universe.add_to_particle_list(particle_name, type)
-    # the line below create an empty particle method for each renderer, eg: browser_left, headless_left, ...
+    # the line below create an empty particle method for each renderer, eg: browser_left, headless_width, ...
     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='
@@ -29,17 +29,20 @@ class Atome
   end
 
   def build_atome(atome_name, &atome_proc)
+    # TODO : atomes should tell the Universe if they're parts of materials category or else
     # we add the new method to the atome's collection of methods
     Universe.add_to_atome_list(atome_name)
     unless Essentials.default_params[atome_name]
       # if it doesn't exist
-      # we create default params for the new created atome, adding the hash to : module essential ,  @default_params
-      Essentials.new_default_params(atome_name => { type: atome_name, children: [], parents: [:view] })
+      # we create default params for the new created atome, adding the hash to : module essential, @default_params
+      Essentials.new_default_params(atome_name => { type: atome_name, attach: [:view] })
     end
 
-    # the line below create an empty atome method for each renderer, eg: browser_left, headless_left, ...
+    # the line below create an empty atome method for each renderer, eg: browser_shape, headless_color, ...
     auto_render_generator(atome_name)
+    # create_atome(atome_name)
     new_atome(atome_name, &atome_proc)
+
   end
 
   def auto_render_generator(element)

data/lib/atome/genesis/sparkle.rb

@@ -26,13 +26,12 @@ puts "current user: #{Universe.current_user}"
 puts "current server: #{Universe.current_server}"
 
 Atome.new(
-  { element: { renderers: [], id: :eDen, type: :element,
-               parents: [], children: [] } }
+  { element: { renderers: [], id: :eDen, type: :element} }
 )
 
 Atome.new(
   { element: { renderers: [], id: :user_view, type: :element,
-               parents: [:eDen], children: [] } }
+               attach: [:eDen] } }
 )
 
 # color creation
@@ -62,6 +61,7 @@ Atome.new(
 )
 
 Atome.new(
+
   { color: { renderers: default_render, id: :matrix_color, type: :color,
              left: 0, top: 0, red: 0.7, green: 0.7, blue: 0.7, alpha: 1, diffusion: :linear } }
 )
@@ -69,13 +69,13 @@ Atome.new(
 # system object creation
 # the black_matter is used to store un materialized atomes
 Atome.new(
-  { shape: { renderers: default_render, id: :black_matter, type: :shape, parents: [:user_view], children: [],
+  { shape: { renderers: default_render, id: :black_matter, type: :shape, attach: [:user_view],
              left: 0, right: 0, top: 0, bottom: 0, width: 0, height: 0, overflow: :hidden
   } })
 # view port
 Atome.new(
-  { shape: { renderers: default_render, id: :view, type: :shape, parents: [:user_view], children: [],
-             attached: [:view_color], left: 0, right: 0, top: 0, bottom: 0, width: :auto, height: :auto, overflow: :auto
+  { shape: { renderers: default_render, id: :view, type: :shape, attach: [:user_view],
+             attached: :view_color, left: 0, right: 0, top: 0, bottom: 0, width: :auto, height: :auto, overflow: :auto,
   }
   }
 )

data/lib/atome/helpers/essentials.rb

@@ -3,28 +3,32 @@
 # use to sanitize and secure user input
 module Essentials
   @default_params = {
+    # Warning :  type must be define first
     render_engines: [:browser],
-    collector: { type: :element, renderers: [], children: [], parents: [:black_matter] },
-    animation: { type: :animation, children: [] , parents: [:black_matter]},
-    element: { type: :element, renderers: [], children: [] , parents: [:black_matter]},
-    matrix: { renderers: [], id: '', type: :shape, width: 99, height: 99,
-              attached: [:matrix_color], children: [],
-              left: 100, top: 100, clones: [], preset: :matrix, parents: [:view] },
-    box: { renderers: [], id: '', type: :shape,  width: 99, height: 99,
-           attached: [:box_color], children: [], parents: [:view],
+    collector: { type: :element, attach: [:black_matter] },
+    image: { type: :image, attach: [:view] },
+    web: { type: :web, attach: [:view] },
+    video: { type: :video, attach: [:view] },
+    animation: { type: :animation,  attach: [:black_matter] },
+    element: { type: :element, renderers: [], attach: [:black_matter] },
+    matrix: { type: :shape, width: 99, height: 99,
+              attached: :matrix_color,
+              left: 100, top: 100, clones: [], preset: :matrix, attach: [:view] },
+    box: { type: :shape, width: 99, height: 99,
+           attached: :box_color, attach: [:view],
            left: 100, top: 100, clones: [], preset: :box },
-    circle: { renderers: [], id: '', type: :shape,  width: 99, height: 99, smooth: '100%',
-              attached: [:circle_color], children: [], parents: [:view],
+    circle: { type: :shape, width: 99, height: 99, smooth: '100%',
+              attached: :circle_color, attach: [:view],
               left: 100, top: 100, clones: [], preset: :circle },
-    shape: { renderers: [], id: '', type: :shape,  width: 99, height: 99,
-             attached: [:shape_color], children: [], parents: [:view],
+    shape: { type: :shape, width: 99, height: 99,
+             attached: :shape_color, attach: [:view],
              left: 100, top: 100, clones: [] },
-    text: { renderers: [], id: '', type: :text, visual: { size: 25 },
-            attached: [:text_color], children: [], parents: [:view],
+    text: { type: :text, visual: { size: 25 },
+            attached: :text_color, attach: [:view],
             data: 'this is a text sample', width: 199, height: 33, clones: [] },
-    drm: { type: :drm,parents: [:black_matter] },
-    shadow: {parents: [:black_matter]},
-    color: {parents: [:black_matter]}
+    drm: { type: :drm, attach: [:black_matter] },
+    shadow: { type: :shadow, attach: [:black_matter] },
+    color: {  type: :color,attach: [:black_matter], red: 0, green: 0, blue: 0, alpha: 1  }
   }
 
   def self.default_params
@@ -32,7 +36,6 @@ module Essentials
   end
 
   def self.new_default_params(new_default)
-    # puts "=====+====> #{new_default}, #{new_default.class}"
     @default_params.merge!(new_default)
   end
 

data/lib/atome/helpers/sanitizer.rb

@@ -10,14 +10,14 @@ class Atome
     { red: split_data[0].to_f / 100, green: split_data[1].to_f / 100, blue: split_data[2].to_f / 100 }
   end
 
-  def found_parents_and_renderers
-    if @atome
-      parent_found = [@atome[:id]]
-      render_found = @atome[:renderers]
-    else
-      parent_found = []
-      render_found = Essentials.default_params[:render_engines]
-    end
-    { parent: parent_found, renderers: render_found }
-  end
+  # def found_parents_and_renderers
+  #   if @atome
+  #     parent_found = [@atome[:id]]
+  #     render_found = @atome[:renderers]
+  #   else
+  #     parent_found = []
+  #     render_found = Essentials.default_params[:render_engines]
+  #   end
+  #   { parent: parent_found, renderers: render_found }
+  # end
 end

data/lib/atome/helpers/utilities.rb

@@ -6,7 +6,7 @@ class Atome
 
   def collapse
     @atome.each do |element, value|
-      send(element, value) unless element == :type
+      send(element, value)
     end
   end
 
@@ -14,22 +14,21 @@ class Atome
     true
   end
 
-  def sanitize(element, params,&user_proc)
+  def sanitize(element, params, &user_proc)
     bloc_found = Universe.get_sanitizer_method(element)
-    params = instance_exec(params,user_proc, &bloc_found) if bloc_found.is_a?(Proc)
+    params = instance_exec(params, user_proc, &bloc_found) if bloc_found.is_a?(Proc)
     params
   end
 
-
   def history(property, value)
     "historize : #{property} #{value}"
   end
 
   def broadcasting(element)
-    params=instance_variable_get("@#{element}")
+    params = instance_variable_get("@#{element}")
     @broadcast.each_value do |particle_monitored|
       if particle_monitored[:particles].include?(element)
-        code_found=particle_monitored[:code]
+        code_found = particle_monitored[:code]
         instance_exec(self, element, params, &code_found) if code_found.is_a?(Proc)
       end
     end
@@ -37,14 +36,14 @@ class Atome
 
   public
 
-  def monitor(params=nil, &proc_monitoring)
+  def monitor(params = nil, &proc_monitoring)
     if params
-      monitoring=atome[:monitor] ||= {}
+      monitoring = atome[:monitor] ||= {}
       params[:atomes].each do |atome_id|
         target_broadcaster = grab(atome_id).instance_variable_get('@broadcast')
         monitor_id = params[:id] || "monitor#{target_broadcaster.length}"
-        monitoring[monitor_id]=params.merge({code: proc_monitoring})
-        target_broadcaster[monitor_id] = { particles: params[:particles], code:  proc_monitoring }
+        monitoring[monitor_id] = params.merge({ code: proc_monitoring })
+        target_broadcaster[monitor_id] = { particles: params[:particles], code: proc_monitoring }
       end
     else
       atome[:monitor]
@@ -59,7 +58,6 @@ class Atome
     instance_variable_set("@#{element}_code", user_proc)
   end
 
-
   def particles(particles_found = nil)
     if particles_found
       particles_found.each do |particle_found, value_found|
@@ -75,7 +73,24 @@ class Atome
     real_atome[property] << value
   end
 
+  def add_to_integer(_atome_found, _particle_found, &_user_proc)
+    puts "there's no interest to add anything to an integer!"
+  end
+
+  def add_to_float(_atome_found, _particle_found, &_user_proc)
+    puts "there's no interest to add anything to an integer!"
+  end
+
+  def add_to_bignum(_atome_found, _particle_found, &_user_proc)
+    puts "there's no interest to add anything to an integer!"
+  end
+
+  def add_to_string(_atome_found, _particle_found, &_user_proc)
+    puts "there's no interest to add anything to an string!"
+  end
+
   def add_to_hash(particle, values, &user_proc)
+    @atome[:add][particle] = true
     # we update  the holder of any new particle if user pass a bloc
     store_code_bloc(particle, &user_proc) if user_proc
     values.each do |value_id, value|
@@ -84,34 +99,51 @@ class Atome
   end
 
   def add_to_array(particle, value, &_user_proc)
+    @atome[:add][particle] = true
     # we update  the holder of any new particle if user pass a bloc
     @atome[particle] << value
   end
 
-  def add_to_atome(atome_found, particle_found, &user_proc)
-    puts "we add : #{particle_found} to #{send(atome_found)} "
-    send(atome_found,particle_found,:adder, &user_proc)
+  def add_to_atome(atome_type, particle_found, &user_proc)
+    # puts "-----> atome_type : #{atome_type}, particle_found : #{particle_found}"
+    # @atome[:add] = [] unless @atome[:add]
+    @atome[:add][atome_type] = particle_found
+    send(atome_type, particle_found, &user_proc)
   end
 
   def add(particles, &user_proc)
+
+    @atome[:add] = {} unless @atome[:add]
     particles.each do |particle, value|
       particle_type = Universe.particle_list[particle] || 'atome'
       send("add_to_#{particle_type}", particle, value, &user_proc)
+      # now we remove systematically the added hash so next particle won't be automatically added
+      @atome[:add].delete(particle)
     end
   end
 
+  def substract(_particles, &_user_proc)
+    # TODO : write code here to remove add elements"
+    puts "write code here to remove add elements"
+    # @atome[:add]=:poi
+    # particles.each do |particle, value|
+    #   particle_type = Universe.particle_list[particle] || 'atome'
+    #   puts "<<<<<< this the place to b ....>>>>>>#{particles} #{particle_type}"
+    #   send("add_to_#{particle_type}", particle, value, &user_proc)
+    # end
+  end
+
   def refresh
     collapse
   end
 
   def collector(params = {}, &bloc)
     atome_type = :collector
-    generated_render = params[:renderers] || []
-    generated_id = params[:id] || identity_generator(atome_type)
-
-    generated_parents = params[:parents] || [id.value]
-    generated_children = params[:children] || []
-    params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
+    # generated_render = params[:renderers] || []
+    # generated_id = params[:id] || identity_generator(atome_type)
+    #
+    # generated_parents = params[:parents] || [id.value]
+    params = atome_common(atome_type, params)
     Batch.new({ atome_type => params }, &bloc)
   end
 
@@ -125,18 +157,16 @@ class Atome
     self.value.include?(value)
   end
 
-
-
-  def each_with_index(*args)
-    self.value.each_with_index do |val, index|
-      yield(val, index)
-    end
+  def each_with_index(*args, &block)
+    value.each_with_index(&block)
   end
 
   def [](range)
-    if value[range].class == Atome
-      return value[range]
-    elsif value[range].class == Array
+    if instance_of?(Atome)
+      value[range]
+      # elsif value[range].instance_of?(Atome)
+      #   return value[range]
+    elsif value[range].instance_of?(Array)
       collector_object = Object.collector({})
       collected_atomes = []
       value[range].each do |atome_found|
@@ -148,6 +178,7 @@ class Atome
     end
 
   end
+
   def []=(params, value)
     # TODO : it may miss some code, see above
     self.value[params] = value
@@ -169,4 +200,25 @@ class Atome
     end
   end
 
+  def materials
+    # TODO: the code below need a rewrite, we must find a new algorythm to avoid all those conditions
+    images_found = atome[:image] || []
+    videos_found = atome[:video] || []
+    shapes_found = atome[:shape] || []
+    web_found = atome[:web] || []
+    texts_found = atome[:text] || []
+    images_found.concat(videos_found).concat(shapes_found).concat(web_found).concat(texts_found)
+  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
+    if atome_to_detach
+      atome_type_found = atome_to_detach.atome[:type]
+      atome_id_found = atome_to_detach.atome[:id]
+      @atome[atome_type_found].delete(atome_id_found)
+      @atome[:attached].delete(atome_id_to_detach)
+    end
+  end
+
 end

data/lib/atome/kernel/batch.rb

@@ -19,7 +19,6 @@ class Batch
   def initialize(params)
     @id = params[:id] || identity_generator(:batch)
     Universe.add_to_atomes(@id, self)
-    Universe.add_to_atomes(@id, self)
   end
 
   def dispatch (method, *args, &block)

data/lib/atome/kernel/universe.rb

@@ -54,7 +54,7 @@ class Universe
 
     def app_identity
       # each app hav its own identity, this allow to generate new user identities from th
-      @app_identity = 3
+      @app_identity = 369
       # the identity is define as follow : parentsCreatorID_softwareInstanceID_objetID
       # in this case parents is eve so 0, Software instance number is main eVe server which is also 0,
       # and finally the object is 3 as this the third object created by the main server