atome 0.5.3.8.1 → 0.5.4.0.9

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-
-
-new({particle: :touch , type: :hash, store: false })
+new({ particle: :touch, type: :hash, store: false })
 new({ post: :touch }) do |params, user_bloc|
   @touch = {} if @touch == nil
   @touch[params] = user_bloc
@@ -10,91 +8,80 @@ new({ post: :touch }) do |params, user_bloc|
   store_value(:touch)
 end
 
-new({particle: :play }) do
+new({ particle: :play }) do
   @atome[:pause] = :false
 end
-new({particle: :time })
-new({particle: :pause }) do
+new({ particle: :time })
+new({ particle: :pause }) do
   @atome[:play] = :false
 end
-new({particle: :on })
-new({particle: :fullscreen })
-new({particle: :mute })
-new({particle: :drag })
-new({ sanitizer: :drag }) do |params|
+new({ particle: :on })
+new({ particle: :fullscreen })
+new({ particle: :mute })
+new({ particle: :drag, store: false })
+
+new({ sanitizer: :drag }) do |params, proc|
   params = { move: true } if params == true
+  params = { end: proc } if params == :end
+  params = { start: proc } if params == :start
+  params
+end
+
+new({ post: :drag }) do |params|
+  # puts  "params is : > #{params}"
+  @drag = {} if @drag == nil
+  # @drag[params] = user_bloc
+  params.each do |k, v|
+    @drag[k] = v
+  end
+  # @drag=params
+  # as store for touch is set to false we have to manually save the instance variable
+  store_value(:drag)
+end
+
+# @touch[params] = user_bloc
+
+new ({ particle: :drop })
+
+new ({ sanitizer: :drop }) do |params|
+  params = { action: true } if params == true
   params
 end
-new({particle: :sort }) do |_value, sort_proc|
+
+new ({ particle: :over })
+
+new ({ sanitizer: :over }) do |params, user_proc|
+
+  params = :enter if params == true
+  case params
+  when :enter
+    @enter_action_proc = user_proc
+  when :leave
+    @leave_action_proc = user_proc
+  end
+  params
+end
+
+new({ particle: :sort }) do |_value, sort_proc|
   @sort_proc = sort_proc
 end
-new({particle: :targets })
-new({particle: :start })
-new({pre: :start }) do |_value, user_proc|
+new({ particle: :targets })
+new({ particle: :start })
+new({ pre: :start }) do |_value, user_proc|
   @animation_start_proc = user_proc
 end
-new({particle: :stop })
-new({pre: :stop })  do |_value, user_proc|
+new({ particle: :stop })
+new({ pre: :stop }) do |_value, user_proc|
   @animation_stop_proc = user_proc
 end
-new({particle: :begin })
-new({particle: :end })
-new({particle: :duration })
-new({particle: :mass })
-new({particle: :damping })
-new({particle: :stiffness })
-new({particle: :velocity })
-new({particle: :repeat })
-new({particle: :ease })
-new({particle: :unbind })
-new({particle: :over })
-
+new({ particle: :begin })
+new({ particle: :end })
+new({ particle: :duration })
+new({ particle: :mass })
+new({ particle: :damping })
+new({ particle: :stiffness })
+new({ particle: :velocity })
+new({ particle: :repeat })
+new({ particle: :ease })
+new({ particle: :unbind })
 
-# generator = Genesis.generator
-#
-# # touch
-# generator.build_particle(:touch)
-# # video
-# generator.build_particle(:play) do
-#   @atome[:pause] = :false
-# end
-# generator.build_particle(:time)
-# generator.build_particle(:pause) do
-#   @atome[:play] = :false
-# end
-# generator.build_particle(:on)
-# generator.build_particle(:fullscreen)
-# generator.build_particle(:mute)
-# # TODO : add the at event to ny particle : (width, left, ...) maybe use monitor particle
-# # generator.build_particle(:at)
-# # drag
-# generator.build_particle(:drag)
-# generator.build_sanitizer(:drag) do |params|
-#   params = { move: true } if params == true
-#   params
-# end
-# # sort
-# generator.build_particle(:sort) do |_value, sort_proc|
-#   @sort_proc = sort_proc
-# end
-# # animation
-# generator.build_particle(:targets)
-# generator.build_particle(:start)
-# generator.build_option(:pre_render_start) do |_value, user_proc|
-#   @animation_start_proc = user_proc
-# end
-# generator.build_particle(:stop)
-# generator.build_option(:pre_render_stop) do |_value, user_proc|
-#   @animation_stop_proc = user_proc
-# end
-# generator.build_particle(:begin)
-# generator.build_particle(:end)
-# generator.build_particle(:duration)
-# generator.build_particle(:mass)
-# generator.build_particle(:damping)
-# generator.build_particle(:stiffness)
-# generator.build_particle(:velocity)
-# generator.build_particle(:repeat)
-# generator.build_particle(:ease)
-# generator.build_particle(:unbind)
-# generator.build_particle(:over)

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

@@ -14,21 +14,3 @@ new({particle: :size }) do |params|
     height(params)
   end
 end
-
-
-# generator = Genesis.generator
-#
-# generator.build_particle(:width)
-# generator.build_particle(:height)
-# generator.build_particle(:size) do |params|
-#   atome_width = atome[:width]
-#   atome_height = atome[:height]
-#   aspect_ratio = atome_width / atome_height
-#   if atome_width > atome_height
-#     width(params)
-#     height(params / aspect_ratio)
-#   else
-#     width(params * aspect_ratio)
-#     height(params)
-#   end
-# end

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

@@ -1,56 +1,72 @@
 # 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 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 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
+  parents_ids
 end
-new({ pre: :attached }) do |children_ids|
+
+new({ particle: :attached })
+new({ sanitizer: :attached }) do |children_ids|
+  children_ids = children_ids 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_id = child_id 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
+    @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.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: :id })
 new({ sanitizer: :id }) do |params|
   if @atome[:id] != params
@@ -62,19 +78,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/material.rb

@@ -30,6 +30,7 @@ new({ pre: :style }) do |styles_send, _user_proc|
   end
 end
 new({ particle: :hide })
+
 new({ particle: :remove }) do |particle_to_remove|
   case particle_to_remove
   when :color
@@ -43,62 +44,10 @@ new({ particle: :remove }) do |particle_to_remove|
 end
 new({ particle: :classes }) do |value|
   Universe.classes[value] ||= []
-  Universe.classes[value] |= [id.value]
+  Universe.classes[value] |= [id]
 end
 new({ particle: :remove_classes }) do |value|
   # Universe.classes.delete(value)
-  Universe.classes[value].delete(id.value)
+  Universe.classes[value].delete(id)
 end
 new ({particle: :opacity})
-
-# generator = Genesis.generator
-#
-# generator.build_particle(:red) do
-#   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-#   self
-# end
-# generator.build_particle(:green) do
-#   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-#   self
-# end
-# generator.build_particle(:blue) do
-#   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-#   self
-# end
-# generator.build_particle(:alpha) do
-#   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-#   self
-# end
-# generator.build_particle(:diffusion) do
-#   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-#   self
-# end
-# generator.build_particle(:visual)
-# generator.build_particle(:overflow)
-# generator.build_particle(:edit)
-# generator.build_particle(:style)
-# generator.build_option(:pre_render_style) do |styles_send, _user_proc|
-#   styles_send.each do |particle_send, value|
-#     send(particle_send, value)
-#   end
-# end
-# generator.build_particle(:hide)
-# generator.build_particle(:remove) do |particle_to_remove|
-#   case particle_to_remove
-#   when :color
-#     send(particle_to_remove, :black)
-#   when :shadow
-#     # TODO : code to write
-#     puts 'code to write'
-#   else
-#     particle_to_remove_decision(particle_to_remove)
-#   end
-# end
-# generator.build_particle(:classes) do |value|
-#   Universe.classes[value] ||= []
-#   Universe.classes[value] |= [id.value]
-# end
-# generator.build_particle(:remove_classes) do |value|
-#   # Universe.classes.delete(value)
-#   Universe.classes[value].delete(id.value)
-# end

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,21 +1,62 @@
 # 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, render: false }) do |params, &user_proc|
   if params == true
-    # the machine delete the current atome
-    Universe.delete(@atome[:id])
+    # We use the tag persistent to exclude color of system object and other default colors
+    unless tag && tag[:persistent]
+      # now we detach the atome from it's parent
+      # now we init rendering
+      rendering(:delete, params, &user_proc)
+      # the machine delete the current atome from the universe
+      id_found = @atome[:id]
+      Universe.delete(id_found)
+      parents_found = @atome[:attach]
+      parents_found.each do |parent_id_found|
+        parent_found = grab(parent_id_found)
+        next unless parent_found
+
+        previous_parent_type_child = parent_found.atome[type]
+        previous_parent_attached_child = parent_found.atome[:attached]
+        # FIXME : find why we can't use delete on the array nut must use an iterator
+        new_type_container = []
+        previous_parent_type_child.each do |atome_found|
+          new_type_container << atome_found unless atome_found == id_found
+        end
+        parent_found.atome[type] = new_type_container
+        # FIXME : find why we can't use delete on the array nut must use an iterator
+        new_attached_container = []
+        previous_parent_attached_child.each do |atome_found|
+          new_attached_container << atome_found unless atome_found == id_found
+        end
+        parent_found.atome[:attached] = new_attached_container
+
+      end
+
+    end
+
+  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
+    # We check for recursive, if found we delete attached atomes too
+    if params[:recursive] == true
+      materials_found = grab(params[:id]).materials
+      materials_found.each do |atome_id_found|
+        grab(atome_id_found).delete(true)
+      end
+    end
     grab(params[:id]).delete(true)
   elsif params.instance_of? Hash
     # the machine try to find the sub particle id and remove it eg a.delete(monitor: :my_monitor) remove the monitor
@@ -24,13 +65,30 @@ new({particle: :delete }) do |params|
       atome[param][value] = nil
     end
   else
-    # the machine try to reset the current particle(params), eg a.delete(:left) => left: 0
     send(params, 0)
   end
 end
-new({particle: :clear })
-new({particle: :path })
-new({particle: :schedule }) do |date, proc|
+
+new({ particle: :clear })
+new({ post: :clear }) do
+
+  attached_found = []
+  @atome[:attached].each do |attached_id_found|
+    attached_found << attached_id_found
+  end
+  attached_found.each do |child_id_found|
+    # puts "===>> should be deleted : #{child_id_found}"
+    child_found = grab(child_id_found)
+
+    child_found.delete(true) if child_found
+
+    # Universe.delete(child_id_found)
+  end
+  # attached([])
+  # puts "params are => #{id}"
+end
+new({ particle: :path })
+new({ particle: :schedule }) do |date, proc|
   date = date.to_s
   delimiters = [',', ' ', ':', '-']
   format_date = date.split(Regexp.union(delimiters))
@@ -38,63 +96,19 @@ 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 })
+new({ particle: :tag, render: false, type: :hash })
+new({ particle: :batch, render: false })
+new({ sanitizer: :batch }) do |params|
+  Batch.new(params)
+  # puts "index msg : we must treat the batch : #{params}"
 
+end
 
-# generator = Genesis.generator
-#
-#
-#
-#
-# generator.build_particle(:renderers)
-# generator.build_particle(:code)
-# generator.build_particle(:run) do |params|
-#   code_found = @atome[:code]
-#   instance_exec(params, &code_found) if code_found.is_a?(Proc)
-# end
-# generator.build_particle(:broadcast)
-# generator.build_particle(:additional)
-# generator.build_particle(:data)
-# generator.build_particle(:delete) do |params|
-#   if params == true
-#     # the machine delete the current atome
-#     Universe.delete(@atome[:id])
-#   elsif params[:id]
-#     # the machine try to an atome by it's ID and delete it
-#     grab(params[:id]).delete(true)
-#   elsif params.instance_of? Hash
-#     # 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
-#   else
-#     # the machine try to reset the current particle(params), eg a.delete(:left) => left: 0
-#     send(params, 0)
-#   end
-# end
-# generator.build_particle(:clear)
-# generator.build_particle(:path)
-# generator.build_particle(:schedule) do |date, proc|
-#   date = date.to_s
-#   delimiters = [',', ' ', ':', '-']
-#   format_date = date.split(Regexp.union(delimiters))
-#   Universe.renderer_list.each do |renderer|
-#     send("#{renderer}_schedule", format_date, &proc)
-#   end
-# end
-# generator.build_particle(:read) do |file, proc|
-#   Universe.renderer_list.each do |renderer|
-#     send("#{renderer}_reader", file, &proc)
-#   end
-# end
-# generator.build_particle(:cursor)
-# generator.build_particle(:preset)
-# generator.build_particle(:relations, { type: :hash })

data/lib/atome/genesis/genesis.rb

@@ -21,7 +21,9 @@ 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, ...
+    # 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='
@@ -29,17 +31,25 @@ 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)
+    # 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]
       # 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)
@@ -57,6 +67,7 @@ class Atome
   end
 
   def build_option(method_name, &method_proc)
+    #puts "2 => #{method_name}"
     Universe.add_optional_method(method_name.to_sym, &method_proc)
   end
 end