atome 0.5.3.7.8 → 0.5.3.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a4400073c94d3ec5f105403f67d7000f183f1cd43b2de943267f2f4dda09248
-  data.tar.gz: cd98e412458149fab7088810f96a39d00035f54d2a5c385b88afc16564ad3aa8
+  metadata.gz: fd6a8f4f6c72f5e9d1974bcf411e6ce19c3469953d39a1ad7ef7de1497626b60
+  data.tar.gz: 2e22cbbe3428e8506c1855fd0dadccfa55e6725912d5adf746963f0754e50884
 SHA512:
-  metadata.gz: 4cb7bb2d5da5fa0021bd568b543cf56a7e172457f3bf8e7907dbaacef4a6a15051bc682145da3447f9d051c0c5ac17bfa5d87038e3a6bdee06a63573efa3947b
-  data.tar.gz: 015efb61571056ffe114372af0bfe87b5a4056ca44ef581d0ec685313598936ea3870ae63d7e47b8017e3d655d77599c279ec540310f82edec50668141678696
+  metadata.gz: '0769c9974cf27f2b275d540baf5f5d22a3a30b979be3c41972fbb246400925864f14299e3fddf4acdf07a89952949dbcbaa96056f14439d27fbb0896d4c4a727'
+  data.tar.gz: 6450a2fa9015d97cd14ca151324d9a70065a4893bd343f80936032ff6f8197ac7d80180d69eb959e5257a622905cb96830ee05dc03aa35c15820e92ca3fc3709

data/exe/atome

@@ -124,11 +124,10 @@ end
 
 def browser_case(location)
   # `cd #{location}/src;open index.html`
-  guard_check
+  # `echo jello`
+  # guard_check
 end
 
-#
-
 def osx_case(location)
   `cd #{location};cargo tauri dev`
 end

data/lib/atome/atome.rb

@@ -3,34 +3,50 @@
 # TODO : remove monitoring
 # TODO : remove child
 # TODO : remove parents
-
+# new({ particle: :type })
+# create_particle(:type, true, true)
 # main entry here
 class Atome
   # TODO : clean or delete @private_atome
   include Essentials
+
   private
 
   def initialize(atomes = {}, &atomes_proc)
+    # puts "atome are #{atomes}"
     atomes.each_value do |elements|
       # the instance variable below contain the id all any atomes that need to be informed when changes occurs
       @broadcast = {}
       # now we store the proc in a an atome's property called :bloc
       elements[:code] = atomes_proc if atomes_proc
       @atome = elements
-      # we initiate the rendering, eg for for browser we will call :browser_type generate method in identity.rb file
-      create_particle(:type, true, true)
-      # set type is a particle method it's dynamically generated at : generator/identity.rb
-      set_type(@atome[:type])
+      # we initiate the rendering suing set_type method,
+      # eg for for browser we will call :browser_type generate method in identity.rb file
+      set_type(@atome[:type], &atomes_proc)
       collapse
+
     end
   end
 
+  def set_type(params, &atomes_proc)
+    # @atome[params]
+    # puts "params is : #{@atome[:children]}"
+    # @atome[:children]={shapes: [params]}
+    # @atome[:shape]=:poil
+    # puts "type is : #{@atome[params].class}"
+    # unless @atome[params]
+    #   @atome[params] = []
+    # end
+    # @atome[params] << params
+    rendering(:type, params, &atomes_proc)
+  end
+
   def new_particle(element, store, render, &method_proc)
     Atome.define_method element do |params = nil, &user_proc|
       if params || params == false
         # the line below execute the proc created when using the build_particle method
         instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
-        params = sanitize(element, params,&user_proc)
+        params = sanitize(element, params, &user_proc)
         create_particle(element, store, render)
         send("set_#{element}", params, &user_proc)
       else
@@ -55,19 +71,20 @@ class Atome
     send("set_#{element}", params, &user_proc)
   end
 
-  def atome_initializer(element, params = {})
-    temp_default = Essentials.default_params[element] || {}
-    generated_render = params[:renderers] || []
-    generated_id = params[:id] || "#{element}_#{Universe.atomes.length}"
-    generated_parents = params[:parents] || [id.value]
-    generated_children = params[:children] || []
-    temp_default[:id] = generated_id
-    temp_default[:parents] = generated_parents
-    temp_default[:clones] = []
-    temp_default[:renderers] = generated_render
-    temp_default[:children] = generated_children
-    temp_default.merge(params)
-  end
+  # def atome_initializer(element, params = {})
+  #   temp_default = Essentials.default_params[element] || {}
+  #   generated_render = params[:renderers] || []
+  #   generated_id = params[:id] || identity_generator(:element)
+  #   alert "generated_parents: #{id.value}"
+  #   generated_parents = params[:parents] || [id.value]
+  #   generated_children = params[:children] || []
+  #   temp_default[:id] = generated_id
+  #   temp_default[:parents] = generated_parents
+  #   temp_default[:clones] = []
+  #   temp_default[:renderers] = generated_render
+  #   temp_default[:children] = generated_children
+  #   temp_default.merge(params)
+  # end
 
   def new_atome(element, &method_proc)
     Atome.define_method element do |params = nil, &user_proc|
@@ -118,10 +135,10 @@ class Atome
     # Params is now an instance variable so it should be passed thru different methods
     instance_variable_set("@#{element}", params) if store
     run_optional_proc("pre_render_#{element}".to_sym, self, params, &user_proc)
-    rendering(element,params, &user_proc) if render
+    rendering(element, params, &user_proc) if render
     run_optional_proc("post_render_#{element}".to_sym, self, params, &user_proc)
     broadcasting(element)
-    store_value(element)  if store
+    store_value(element) if store
     self
   end
 

data/lib/atome/extensions/atome.rb

@@ -46,7 +46,8 @@ end
 def create_method_at_object_level(element)
 
   Object.define_method element do |params, &user_proc|
-    grab(:view).send(element, params, &user_proc)
+    default_parent=Essentials.default_params[element][:parents][0]# we get the first parents
+    grab(default_parent).send(element, params, &user_proc)
   end
 
 end

data/lib/atome/extensions/matrix.rb

@@ -242,7 +242,6 @@ module Matrix
     default_renderer = Essentials.default_params[:render_engines]
     atome_type = :matrix
     generated_render = params[:renderers] || default_renderer
-    # generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
     generated_id = params[:id] || identity_generator(:matrix)
 
     generated_parents = params[:parents] || [id.value]

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

@@ -1,18 +1,22 @@
 # frozen_string_literal: true
 
-new({ atome: :color })
+new({ atome: :color, type: :hash })
 
 new({ sanitizer: :color }) do |params|
-  # we delete any previous color if there's one
-  if color.value
-    attached.value.delete(color.value)
-    grab(color.value)&.delete(true) # we had the condition because the color may exist but 
+  parent_found = found_parents_and_renderers[:parent]
+  if parent_found == [:black_matter]
+
+  elsif color.value
+    # we delete any previous color if there's one
+    detached(color.value)
+    grab(color.value)&.delete(true) # we had the condition because the color may exist but
     # so it is not sanitized so it has no id
   end
-  parent_found = found_parents_and_renderers[:parent]
-  parent_found = [:black_matter] if parent_found == [:view]
+
   render_found = found_parents_and_renderers[:renderers]
-  default_params = { renderers: render_found, id: "color_#{Universe.atomes.length}", type: :color,
+  generated_id = params[:id] || identity_generator(:color)
+
+  default_params = { renderers: render_found, id: generated_id, type: :color,
                      attach: parent_found,
                      red: 0, green: 0, blue: 0, alpha: 1 }
   params = create_color_hash(params) unless params.instance_of? Hash
@@ -28,7 +32,8 @@ new({ sanitizer: :image }) do |params|
     params = { path: "./medias/images/#{params}" }
   end
   default_renderer = Essentials.default_params[:render_engines]
-  generated_id = params[:id] || "image_#{Universe.atomes.length}"
+  generated_id = params[:id] || identity_generator(:image)
+
   generated_render = params[:renderers] || default_renderer
   generated_parents = params[:parents] || id.value
   # TODO : the line below should get the value from default params Essentials
@@ -41,22 +46,36 @@ new({ atome: :video })
 new({ sanitizer: :video }) do |params|
   parent_found = found_parents_and_renderers[:parent]
   render_found = found_parents_and_renderers[:renderers]
-  default_params = { renderers: render_found, id: "video_#{Universe.atomes.length}", type: :video,
+  generated_id = params[:id] || identity_generator(:video)
+
+  default_params = { renderers: render_found, id: generated_id, type: :video,
                      parents: parent_found }
   default_params.merge!(params)
 end
 new({ atome: :shadow })
 new({ sanitizer: :shadow }) do |params|
-  # we delete any previous shadow if there's one
-  if shadow.value
-    attached.value.delete(shadow.value)
-    grab(shadow.value)&.delete(true) # we had the condition because the color may exist but 
+
+  parent_found = found_parents_and_renderers[:parent]
+  if parent_found == [:view]
+    parent_found = [:black_matter] if parent_found == [:view]
+  elsif shadow.value
+    # we delete any previous color if there's one
+    detached(shadow.value)
+    grab(shadow.value)&.delete(true) # we had the condition because the shadow may exist but
     # so it is not sanitized so it has no id
   end
-  parent_found = found_parents_and_renderers[:parent]
-  parent_found = [:user_view] if parent_found == [:view]
+  ## we delete any previous shadow if there's one
+  # if shadow.value
+  #   attached.value.delete(shadow.value)
+  #   grab(shadow.value)&.delete(true) # we had the condition because the color may exist but 
+  #   # so it is not sanitized so it has no id
+  # end
+  # parent_found = found_parents_and_renderers[:parent]
+  # parent_found = [:user_view] if parent_found == [:view]
   render_found = found_parents_and_renderers[:renderers]
-  default_params = { renderers: render_found, id: "shadow_#{Universe.atomes.length}", type: :shadow,
+  generated_id = params[:id] || identity_generator(:shadow)
+
+  default_params = { renderers: render_found, id: generated_id, type: :shadow,
                      attach: parent_found,
                      red: 0, green: 0, blue: 0, alpha: 1, blur: 3, left: 3, top: 3 }
   # default_params.merge!(params)
@@ -73,15 +92,17 @@ new({ atome: :element })
 new({ sanitizer: :element }) do |params|
   parent_found = found_parents_and_renderers[:parent]
   render_found = []
-  default_params = { renderers: render_found, id: "element_#{Universe.atomes.length}", type: :element,
+  generated_id = params[:id] || identity_generator(:element)
+
+  default_params = { renderers: render_found, id: generated_id, type: :element,
                      parents: parent_found, data: '' }
   default_params.merge!(params)
 end
 new({ atome: :web })
 new({ sanitizer: :web }) do |params|
   default_renderer = Essentials.default_params[:render_engines]
+  generated_id = params[:id] || identity_generator(:web)
 
-  generated_id = params[:id] || "web_#{Universe.atomes.length}"
   generated_render = params[:renderers] || default_renderer
   generated_parents = params[:parents] || id.value
   # TODO : the line below should get the value from default params Essentials
@@ -96,19 +117,19 @@ new({ sanitizer: :animation }) do |params|
   default_renderer = Essentials.default_params[:render_engines]
   atome_type = :animation
   generated_render = params[:renderers] || default_renderer
-  generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
+  generated_id = params[:id] || identity_generator(atome_type)
   generated_parents = params[:parents] || []
   generated_children = params[:children] || []
   params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
   params
 end
-new({ atome: :text })
+new({ atome: :text, type: :hash })
 new({ sanitizer: :text }) do |params|
   params = { data: params } unless params.instance_of? Hash
   default_renderer = Essentials.default_params[:render_engines]
   atome_type = :text
   generated_render = params[:renderers] || default_renderer
-  generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
+  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)

data/lib/atome/genesis/genesis.rb

@@ -31,6 +31,12 @@ class Atome
   def build_atome(atome_name, &atome_proc)
     # 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] })
+    end
+
     # the line below create an empty atome method for each renderer, eg: browser_left, headless_left, ...
     auto_render_generator(atome_name)
     new_atome(atome_name, &atome_proc)

data/lib/atome/helpers/essentials.rb

@@ -4,27 +4,27 @@
 module Essentials
   @default_params = {
     render_engines: [:browser],
-    collector: { type: :element, renderers: [], children: [] },
-    animation: { type: :animation, children: [] },
-    element: { type: :element, renderers: [], children: [] },
-    matrix: { renderers: [], id: '', type: :shape, parents: [], width: 99, height: 99,
+    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 },
-    box: { renderers: [], id: '', type: :shape, parents: [], width: 99, height: 99,
-           attached: [:box_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],
            left: 100, top: 100, clones: [], preset: :box },
-    circle: { renderers: [], id: '', type: :shape, parents: [], width: 99, height: 99, smooth: '100%',
-              attached: [:circle_color], children: [],
+    circle: { renderers: [], id: '', type: :shape,  width: 99, height: 99, smooth: '100%',
+              attached: [:circle_color], children: [], parents: [:view],
               left: 100, top: 100, clones: [], preset: :circle },
-    shape: { renderers: [], id: '', type: :shape, parents: [], width: 99, height: 99,
-             attached: [:shape_color], children: [],
+    shape: { renderers: [], id: '', type: :shape,  width: 99, height: 99,
+             attached: [:shape_color], children: [], parents: [:view],
              left: 100, top: 100, clones: [] },
-    text: { renderers: [], id: '', type: :text, parents: [:view], visual: { size: 25 },
-            attached: [:text_color], children: [],
+    text: { renderers: [], id: '', type: :text, visual: { size: 25 },
+            attached: [:text_color], children: [], parents: [:view],
             data: 'this is a text sample', width: 199, height: 33, clones: [] },
-    drm: { type: :drm },
-    shadow: {},
-    color: {}
+    drm: { type: :drm,parents: [:black_matter] },
+    shadow: {parents: [:black_matter]},
+    color: {parents: [:black_matter]}
   }
 
   def self.default_params
@@ -32,6 +32,7 @@ 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/utilities.rb

@@ -6,7 +6,6 @@ class Atome
 
   def collapse
     @atome.each do |element, value|
-      # puts "=============> #{element}"
       send(element, value) unless element == :type
     end
   end
@@ -89,9 +88,14 @@ class Atome
     @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)
+  end
+
   def add(particles, &user_proc)
     particles.each do |particle, value|
-      particle_type = Universe.particle_list[particle]
+      particle_type = Universe.particle_list[particle] || 'atome'
       send("add_to_#{particle_type}", particle, value, &user_proc)
     end
   end
@@ -103,7 +107,8 @@ class Atome
   def collector(params = {}, &bloc)
     atome_type = :collector
     generated_render = params[:renderers] || []
-    generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
+    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)

data/lib/atome/kernel/batch.rb

@@ -17,7 +17,6 @@ class Batch
   end
 
   def initialize(params)
-    # @id = params[:id] || "batch_#{Universe.atomes.length}"
     @id = params[:id] || identity_generator(:batch)
     Universe.add_to_atomes(@id, self)
     Universe.add_to_atomes(@id, self)
@@ -29,7 +28,7 @@ class Batch
     end
   end
 
-  # TODO:  automatise collector methods creation when creato,g a new atome type
+  # TODO:  automatise collector methods creation when creating a new atome type
   def color(args, &block)
 
     dispatch(:color, args, &block)

data/lib/atome/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Atome
-  VERSION = '0.5.3.7.8'
+  VERSION = '0.5.3.8.1'
 end

data/vendor/assets/src/medias/rubies/examples/!run.rb

@@ -8,7 +8,7 @@ top touch video wait web width]
     wait 1 * index do
       puts toto
       read("examples/#{toto}.rb", :ruby)
-      `console.clear()`
+      # `console.clear()`
     end
   end
 end

data/vendor/assets/src/medias/rubies/examples/detached.rb

@@ -4,10 +4,10 @@ color({ red: 0.8, green: 0.8, blue: 0.8, id: :active_color })
 color( { red: 0.3, green:  0.3, blue: 0.3, id: :inactive_color } )
 
 b=box
-b.attached([:inactive_color])
+b.attached(:inactive_color)
 puts b.attached
 b.touch(true) do
-  b.detached([:inactive_color])
-  b.attached([:active_color])
+  b.detached(:inactive_color)
+  b.attached(:active_color)
   puts b.attached
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atome
 version: !ruby/object:Gem::Version
-  version: 0.5.3.7.8
+  version: 0.5.3.8.1
 platform: ruby
 authors:
 - Jean-Eric Godard
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-02-14 00:00:00.000000000 Z
+date: 2023-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: arduino_firmata