atome 0.5.4.1.9 → 0.5.5.6.4

data/lib/atome/atome.rb

@@ -1,171 +1,67 @@
 # frozen_string_literal: true
 
-# TODO : remove monitoring
-# TODO : remove child
-# TODO : remove parents
-
-# main entry here
+# main Atome entry here
 class Atome
-  # TODO : clean or delete @private_atome
   include Essentials
 
-  private
-
-  def initialize(atomes = {}, &atomes_proc)
-
-    atomes.each_value do |elements|
-
-      if  Universe.atomes.key?(elements[:id])
-        puts "The id #{elements[:id]} is already taken, you must change it"
-        # `throw new Error("this id is already exist, you must change it");`
-      else
-        # 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 suing set_type method,
-        # eg for for browser we will call :browser_type generate method in identity.rb file
-        collapse
-      end
-    end
-  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)
-        create_particle(element, store, render)
-        send("set_#{element}", params, &user_proc)
-      elsif element == :batch # TODO : find a better solution than a condition if possible
-        @atome[:batch]
-      else
-
-        @atome[element]
-        # get_particle(element, &user_proc)
-      end
-    end
-  end
-
-  def additional_particle_methods(element, store, render, &method_proc)
-    Atome.define_method "#{element}=" do |params = nil, &user_proc|
-      instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
-      params = sanitize(element, params)
-      particle_creation(element, params, store, render, &user_proc)
-    end
+  def initialize(new_atome = {}, &atomes_proc)
+    # the keys :renderers, :type and :id should be placed in the first position in the hash
+    #@broadcast = {}
+    @history = {}
+    @callback = {}
+    @tag = {}
+    @selected = false
+    @unit = {}
+    @collect = {}
+    @id = new_atome[:id] || identity_generator(:element)
+    @type = new_atome[:type] || :element
+    @attached = []
+    @category = []
+    @display = { mode: :default, default: {} }
+    # @copy = []
+    @html = HTML.new(@id, self)
+    @headless = Headless.new(@id, self)
+    # now we store the proc in a an atome's property called :bloc
+    new_atome[:code] = atomes_proc if atomes_proc
+    # we reorder the hash
+    ordered_keys = %i[renderers id type]
+    ordered_part = ordered_keys.map { |k| [k, new_atome[k]] }.to_h
+    other_part = new_atome.reject { |k, _| ordered_keys.include?(k) }
+    # merge the parts  to obtain an re-ordered hash
+    reordered_atome = ordered_part.merge(other_part)
+
+    # FIXME : try to remove the condition below (it crash in the method :  def generator ... in genesis.rb)
+    collapse(reordered_atome)
   end
 
-  def atome_parsing(element, params, &user_proc)
-    params = sanitize(element, params)
-    current_atome = send(element)
-
-    # The condition below check if we need to add or replace the newly created atome
-    if current_atome && !(@atome[:add] && @atome[:add][element])
-      detached(current_atome)
-      @atome[element] = []
-    end
-    # TODO :replace with the line below but need extensive testing as it crash some demos ex: animation
-    params = atome_common(element, params)
-    run_optional_proc("pre_render_#{@atome[:type]}".to_sym, self, params, &user_proc)
-    run_optional_proc("post_render_#{@atome[:type]}".to_sym, self, params, &user_proc)
-    send("set_#{element}", params, &user_proc) # it call  Atome.define_method "set_#{element}" in  new_atome method
-  end
-
-  def atome_catcher(atome_catch)
-    # puts "atome_catch is : #{atome_catch.class}"
-    atome_catch
-  end
-
-  def new_atome(element, &method_proc)
-    # the method define below is the slowest but params are analysed and sanitized
-    Atome.define_method element do |params = nil, &user_proc|
-      if params
-        instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
-        atome_parsing(element, params, &user_proc)
-      else
-        # puts "******> we are searching for the atome return(noobs) #{element} : #{id}"
-        # puts  "no atome params"
-        atome_catcher(@atome[element])
-      end
-
-    end
-
-    # the method define below is the fastest params are passed directly
-    Atome.define_method "set_#{element}" do |params, &user_proc|
-      # 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]
-      new_atome = Atome.new({ element => params }, &user_proc)
-      # Now we return the newly created atome instead of the current atome that is the parent cf: b=box; c=b.circle
-      # c must return the circle not the parent box
-      # puts "******> we are searching for the atome return(set) #{element} : #{id}"
-      #   puts  "no set  atome params"
-      atome_catcher(new_atome)
-
-    end
-    # the method below generate Atome method creation at Object level
-    # create_method_at_object_level(element)
-  end
+  def particle_creation(element, params, store, rendering, &user_proc)
 
-  def new_render_engine(renderer_name, &method_proc)
-    Atome.define_method renderer_name do |params = nil, &user_proc|
-      instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
-    end
-  end
-
-  def run_optional_proc(proc_name, atome = self, params, &user_proc)
-    # params = instance_variable_get("@#{element}")
-    option_found = Universe.get_optional_method(proc_name)
-
-    # if option_found.is_a?(Proc)
-    #   # alert  "#{proc_name} : #{params} "
-    # else
-    #   puts "proc_name : #{proc_name}, \noption_found : (#{option_found})"
-    # end
-    atome.instance_exec(params, user_proc, atome, &option_found) if option_found.is_a?(Proc)
-  end
-
-  def store_value(element)
-    params = instance_variable_get("@#{element}")
-    @atome[element] = params
-  end
-
-  public
-
-  # the line below is used for ephemera atomes
-  attr_accessor :property, :value, :real_atome, :user_proc
-  attr_reader :atome, :structure # , :at_time
-
-  def set(value)
-    @real_atome[@property] = value
-  end
-
-  def particle_creation(element, params, store, render, &user_proc)
-    return false unless security_pass(element, params)
-
-    # we create a proc holder of any new particle if user pass a bloc
-    store_code_bloc(element, &user_proc) if user_proc
+    # @store_allow = false
+    params = particle_main(element, params, &user_proc)
     # 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}", self, params, &user_proc)
-    rendering(element, params, &user_proc) if render
-    run_optional_proc("post_render_#{element}", self, params, &user_proc)
-    broadcasting(element)
-    store_value(element) if store
-    self
-  end
+    # pre rendering processor
+    params = particle_pre(element, params, &user_proc)
+    # we create a proc holder of any new particle if user pass a bloc
+    particle_callback(element)
+    store_proc(element, params, &user_proc) if user_proc
+    render(element, params, &user_proc) if rendering
+    # broadcasting(element)
+    # post rendering processor
+    params = particle_post(element, params, &user_proc)
+    instance_variable_set("@#{element}", params) if store
+    # post storage processor
+    particle_after(element, params, &user_proc)
 
-  def create_particle(element, store, render)
-    Atome.define_method "set_#{element}" do |params, &user_proc|
-      particle_creation(element, params, store, render, &user_proc)
-    end
+    # self
   end
 
-  def get(element)
-    @atome[element]
-  end
+  def inspect
+    filtered_vars = instance_variables.reject { |var| var == :@html_object || var == :@history }
+    content = filtered_vars.map do |var|
+      "#{var}=#{instance_variable_get(var).inspect}"
+    end.join(", ")
 
-  Universe.connected
+    "#<#{self.class}: #{content}>"
+  end
 end

data/lib/atome/extensions/atome.rb

@@ -1,87 +1,169 @@
 # frozen_string_literal: true
 
+# atome extensions
 class Object
   def new(params, &bloc)
-    generator = Genesis.generator
-    if params.key?(:particle)
+    # Genesis = Genesis.Genesis
+    if params.key?(:atome)
+      Universe.add_atomes_specificities params[:atome]
+      Genesis.build_atome(params[:atome], &bloc)
+    elsif params.key?(:particle)
+      Atome.instance_variable_set("@main_#{params[:particle]}", bloc)
       # render indicate if the particle needs to be rendered
       # store tell the system if it need to store the particle value
       # type help the system what type of type the particle will receive and store
-      generator.build_particle(params[:particle], { render: params[:render], return: params[:return],
-                                                    store: params[:store], type: params[:type] }, &bloc)
-    elsif params.key?(:atome)
-      atome_return = params[:return] || params[:atome]
-      generator.build_atome(params[:atome], &bloc)
+      Genesis.build_particle(params[:particle], { render: params[:render], return: params[:return],
+                                                  store: params[:store], type: params[:type] }, &bloc)
     elsif params.key?(:sanitizer)
-      generator.build_sanitizer(params[:sanitizer], &bloc)
+      Genesis.build_sanitizer(params[:sanitizer], &bloc)
     elsif params.key?(:pre)
-      generator.build_option("pre_render_#{params[:pre]}", &bloc)
+      Atome.instance_variable_set("@pre_#{params[:pre]}", bloc)
     elsif params.key?(:post)
-      generator.build_option("post_render_#{params[:post]}", &bloc)
-    elsif params.key?(:browser)
-      generator.build_render("browser_#{params[:browser]}", &bloc)
+      Atome.instance_variable_set("@post_#{params[:post]}", bloc)
+    elsif params.key?(:after)
+      Atome.instance_variable_set("@after_#{params[:after]}", bloc)
+    elsif params.key?(:read)
+      Atome.instance_variable_set("@read_#{params[:read]}", bloc)
+    elsif params[:renderer]
+      renderer_found = params[:renderer]
+      if params[:specific]
+        Universe.set_atomes_specificities(params)
+        params[:specific] = "#{params[:specific]}_"
+      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" do
+        bloc.call
+      end
     end
   end
 
-  def batch (atomes)
-    grab(:black_matter).batch(atomes)
+  def delete (atomes)
+    grab(:view).delete(atomes)
   end
 
-  def identity_generator(type = :element)
-    "#{attach[0]}_#{type}_#{Universe.counter}"
+  def identity_generator(type_needed = :element)
+    "#{type_needed}_#{Universe.counter}"
   end
 
-  def grab(atome_to_get)
+  def grab(id_to_get)
+    return if id_to_get == false
 
-    Universe.atomes[atome_to_get]
+    id_to_get = '' if id_to_get.instance_of? Array
+    id_to_get = id_to_get.to_sym
+    Universe.atomes[id_to_get]
   end
 
   def box(params = {}, &proc)
     grab(:view).box(params, &proc)
   end
 
-  def vector(params = {}, &proc)
-    grab(:view).vector(params, &proc)
-  end
-
   def circle(params = {}, &proc)
     grab(:view).circle(params, &proc)
   end
 
-  def matrix(params = {}, &proc)
-    grab(:view).matrix(params, &proc)
-  end
-
-  # def method_missing(method, *args, &block)
-  #   args.each do |atome_found|
-  #     args.each do |arg|
-  #       default_parent = Essentials.default_params[method][:attach][0] # we get the first parents
-  #       # create_method_at_object_level(element)
-  #       atome_found = grab(default_parent).send(method, arg, &block)
-  #       # we force then return of atome found else its return an hash # TODO : we may find a cleaner solution
-  #       return atome_found
-  #     end
-  #   end
-  # 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|
-      default_parent = Essentials.default_params[element][:attach][0] # we get the first parents
+      default_parent = Essentials.default_params[element][:attach] || :view
       grab(default_parent).send(element, params, &user_proc)
     end
   end
 
-  def atome_method_for_batch(element)
-    Batch.define_method element do |params, &user_proc|
-      dispatch(element, [params], &user_proc)
+  def wait(time, id = nil, &proc)
+    # we generate an uniq id
+    if [:kill, 'kill'].include?(time)
+      JS.eval("clearTimeout(window.timeoutIds['#{id}']);")
+    else
+      obj = Object.new
+      unique_id = obj.object_id
+
+      id ||= unique_id
+      time *= 1000
+      callback_id = "myRubyCallback_#{id}"
+      JS.global[callback_id.to_sym] = proc
+      JS.eval("if (!window.timeoutIds) { window.timeoutIds = {}; } window.timeoutIds['#{id}'] = setTimeout(function() { #{callback_id}(); }, #{time});")
     end
+    id
+  end
+
+  def repeater(counter, proc)
+    instance_exec(counter, &proc) if proc.is_a?(Proc)
   end
-  def particle_method_for_batch(element)
-    Batch.define_method element do |params, &user_proc|
-      dispatch(element, [params], &user_proc)
+
+  def repeat_callback(params, counter)
+    @repeat[params].call(counter)
+  end
+
+  def repeat(delay = 1, repeat = 0, &proc)
+    @repeat ||= []
+    @repeat << proc
+    repeat_id = @repeat.length - 1
+    intervalId = JS.eval(<<~JS)
+                function repeat(action, interval, repetitions) {
+               let count = 0;
+               let intervalId = null;
+
+               function executeAction() {
+                   if (count < repetitions) {
+                       action(count);
+                       count++;
+                   } else {
+                       clearInterval(intervalId);
+                   }
+               }
+
+               executeAction(); // execute immediatly
+               intervalId = setInterval(executeAction, interval);
+               return intervalId;
+           }
+
+           function myAction(counter) {
+               rubyVMCallback("repeat_callback(#{repeat_id}, "+counter+")")
+           }
+
+           const intervalId = repeat(myAction, #{delay} * 1000, #{repeat}); 
+
+      return intervalId;
+    JS
+    intervalId
+
+  end
+
+  def stop(params)
+    case params
+    when Hash
+      if params.key?(:repeat)
+        repeater_to_stop = params[:repeat]
+        JS.eval(<<~JS)
+          clearInterval(#{repeater_to_stop});
+        JS
+      else
+        puts "La clé :repeat n'existe pas dans params"
+      end
+    else
+      puts "params n'est pas un hash"
+    end
+  end
+
+  def tagged(params)
+    atome_get = []
+    if params.instance_of? Hash
+      params.each do |tag_name, tag_value|
+        Universe.atomes.each do |atomes_id_found, atomes_found|
+          if atomes_found.tag&.instance_of?(Hash) && (atomes_found.tag[tag_name] == tag_value)
+            atome_get << atomes_id_found
+          end
+        end
+      end
+    else
+      Universe.atomes.each do |atomes_id_found, atomes_found|
+        atome_get << atomes_id_found if atomes_found.tag&.instance_of?(Hash) && atomes_found.tag[params]
+      end
     end
+    atome_get
   end
 
-end
+end

data/lib/atome/extensions/mathematics.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Basic add on
+class Atome
+  def /(other)
+    value / other
+  end
+
+  def *(other)
+    value * other
+  end
+
+  def -(other)
+    value - other
+  end
+
+  def +(other)
+    value + other
+  end
+end

data/lib/atome/extensions/ping.rb

@@ -5,11 +5,10 @@ class Atome
   def up?(host, _my_proc)
     check = Net::Ping::External.new(host)
     return unless check.ping?
-
-    puts 'ping respond!!'
+    'ping respond!!'
   end
 
   def ping(address, my_proc: false)
-    puts up(address, my_proc) # prints "true" if ping replies
+    up(address, my_proc) # prints "true" if ping replies
   end
 end

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

@@ -1,20 +1,23 @@
 # frozen_string_literal: true
 new({ atome: :color, type: :hash })
-
 new({ sanitizer: :color }) do |params|
-  # TODO : when attaching color to a shadow it should colorized it , cf : c.shadow({color: :blue}) should work
   params = create_color_hash(params) unless params.instance_of? Hash
+  # the condition below is to prevent the creation of multiple unwanted colors with same property and no ID specified
+  unless params[:id]
+    uniq_value = "#{params[:red].to_s.sub('.', '_')}_#{params[:green].to_s.sub('.', '_')}_#{params[:blue].to_s.sub('.', '_')}_#{params[:alpha].to_s.sub('.', '_')}_#{params[:left].to_s.sub('.', '_')}_#{params[:top].to_s.sub('.', '_')}_#{params[:diffusion].to_s.sub('.', '_')}"
+    params[:id] = "#{@id}_color_#{uniq_value}".to_sym
+  end
   params
 end
-
+# new({ post: :color }) do
+#   Atome.global_monitoring(self, [:red, :blue, :blue, :alpha, :left, :right, :diffusion], [:variable1, :variable2])
+# end
 new({ atome: :image })
 new({ sanitizer: :image }) do |params|
   unless params.instance_of? Hash
     # TODO : we have to convert all image to png or maintain a database with extension
     # FIXME : temporary patch that add .png to the string if no extension is found
-    if params.split('.').length == 1
-      params = "#{params}.png"
-    end
+    params = "#{params}.png" if params.to_s.split('.').length == 1
 
     params = { path: "./medias/images/#{params}" }
   end
@@ -22,25 +25,27 @@ new({ sanitizer: :image }) do |params|
   params
 end
 new({ atome: :video })
+new({ sanitizer: :video }) do |params|
+  unless params.instance_of? Hash
+    # TODO : we have to convert all image to png or maintain a database with extension
+    # FIXME : temporary patch that add .mp4 to the string if no extension is found
+    params = "#{params}.mp4" if params.to_s.split('.').length == 1
 
-new({ atome: :shadow, type: :hash })
-new({ sanitizer: :shadow }) do |params|
-  # TODO : when attaching color to a shadow it should colorised it , cf : c.shadow({color: :blue}) should work
-  params = {} unless params.instance_of? Hash
-  default_params = { red: 0, green: 0, blue: 0, alpha: 1, blur: 3, left: 3, top: 3 }
-  new_params = default_params.merge!(params)
-  new_params
+    params = { path: "./medias/videos/#{params}" }
+  end
+  # TODO : the line below should get the value from default params Essentials
+  params
+end
+new({ atome: :www })
+new({ atome: :shadow }) do |params|
+  if params
+    attach_value = params.delete(:affect)
+    params[:affect] = attach_value
+  end
+  params
 end
+new({ atome: :raw })
 new({ atome: :shape })
-# new({ pre: :shape }) do |params|
-#   if params[:definition]
-#     # if it is a vector we reorder tha params
-#     attached = params.delete(:attached)
-#     params = params.merge({ attached: attached })
-#   end
-#
-#   params
-# end
 new({ atome: :code })
 new({ atome: :audio })
 new({ atome: :element })
@@ -48,17 +53,39 @@ new({ sanitizer: :element }) do |params|
   default_params = { data: '' }
   default_params.merge!(params)
 end
-new({ atome: :web })
-new({ sanitizer: :web }) do |params|
-  # TODO : the line below should get the value from default params Essentials
-  temp_default = { path: 'https://www.youtube.com/embed/usQDazZKWAk' }
-  params = temp_default.merge(params)
-  params
-end
-new({ atome: :collector })
 new({ atome: :animation })
+new({ atome: :group })
 new({ atome: :text, type: :hash })
+new({ post: :text }) do |params|
+  data_found = params[:data]
+  if data_found.instance_of? Array
+    data_found.each_with_index do |data_found, index|
+      # we treat the first element
+      if index == 0
+        send(:data, data_found)
+      else
+        # we create new text's atome attached to the main one (the first element above)
+        text(data_found)
+      end
+
+    end
+  else
+    send(:data, data_found)
+  end
+  params
+end
 new({ sanitizer: :text }) do |params|
+  # to allow text api with the form text(:hello) instead of text({data: :hello})
   params = { data: params } unless params.instance_of? Hash
   params
 end
+# for later use ( physical is a css like style)
+new({ atome: :human }) do |params|
+  Universe.add_user = params[:id]
+end
+new({ atome: :machine })
+
+new({ atome: :paint })
+new({ atome: :vector })
+
+

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

@@ -1,2 +1,11 @@
 # frozen_string_literal: true
 
+new({ particle: :connection }) do |params, bloc|
+  params = { server: params } unless params.instance_of? Hash
+  html.connect(params[:server], &bloc)
+end
+
+new({ particle: :message }) do |params, bloc|
+  params = { server: params } unless params.instance_of? Hash
+  html.send_message(params[:server], &bloc)
+end

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
 
-
 new({ particle: :smooth })
 new({ particle: :blur })