atome 0.5.6.1.4 → 0.5.6.2.0

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

@@ -9,29 +9,29 @@ def extract_rgb_alpha(color_string)
   { red: red, green: green, blue: blue, alpha: alpha }
 end
 
-new({ particle: :red }) do
+new({ particle: :red, category: :property, type: :string }) do
   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
   self
 end
-new({ particle: :green }) do
+new({ particle: :green, category: :property, type: :string }) do
   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
   self
 end
-new({ particle: :blue }) do
+new({ particle: :blue, category: :property, type: :string }) do
   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
   self
 end
-new({ particle: :alpha }) do
+new({ particle: :alpha, category: :property, type: :string }) do
   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
   self
 end
-new({ particle: :diffusion }) do
+new({ particle: :diffusion, category: :property, type: :string }) do
   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
   self
 end
 
 
-new({ particle: :clean }) do |params|
+new({ particle: :clean, category: :property, type: :boolean }) do |params|
   cell = params[:cell]
   row_nb = cell[0]
   column_nb = cell[1]
@@ -39,7 +39,7 @@ new({ particle: :clean }) do |params|
   params
 end
 
-new({ particle: :insert }) do |params|
+new({ particle: :insert, category: :property, type: :string }) do |params|
   # cell
   if params[:cell]
     content = params[:content]
@@ -56,23 +56,7 @@ new({ particle: :insert }) do |params|
   params
 end
 
-new({ particle: :remove }) do |params|
-
-  if params[:row]
-    data.delete_at(params[:row])
-
-  elsif params[:column]
-    column = params[:column]
-    data.map do |hash|
-      hash.delete(hash.keys[column]) if hash.keys[column]
-      hash
-    end
-  end
-  params
-end
-
-
-new({ particle: :sort }) do |params|
+new({ particle: :sort, category: :property, type: :int }) do |params|
   column = params[:column]
   method = params[:method]
 

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-new ({ particle: :password })
+new ({ particle: :password, category: :security, type: :string })
 new ({ sanitizer: :password }) do |params|
 
   params = { read: params, write: params } unless params.instance_of? Hash

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

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-new({ particle: :left })
-new({ particle: :right })
-new({ particle: :top })
-new({ particle: :bottom })
-new({ particle: :rotate, type: :integer })
-new({ particle: :direction, type: :string })
-new({ particle: :depth, type: :integer })
-new({ particle: :position })
-new({ particle: :organise })
-new({ particle: :spacing })
-new({ particle: :display }) do |params|
+new({ particle: :left, category: :spatial, type: :int })
+new({ particle: :right, category: :spatial, type: :int })
+new({ particle: :top, category: :spatial, type: :int })
+new({ particle: :bottom, category: :spatial, type: :int })
+new({ particle: :rotate, category: :spacial, type: :integer })
+new({ particle: :direction, category: :spatial, type: :string })
+new({ particle: :depth, category: :spatial, type: :integer })
+new({ particle: :position, category: :spatial, type: :int })
+new({ particle: :organise, category: :spatial, type: :string })
+new({ particle: :spacing, category: :spatial, type: :string })
+new({ particle: :display, category: :spatial, type: :boolean }) do |params|
   params = { mode: params } unless params.instance_of? Hash
   params
 end
-new({ particle: :layout }) do |params|
+new({ particle: :layout, category: :spatial, type: :int }) do |params|
   mode_found = params.delete(:mode) || :list
   elements_style = params.delete(:element) || {}
   # now we get the list of the atome to layout
@@ -86,7 +86,7 @@ new({ particle: :layout }) do |params|
   end
   params
 end
-new({ particle: :center, type: :hash }) do |params|
+new({ particle: :center, category: :spatial, type: :hash }) do |params|
   params = { x: 0, y: 0, dynamic: true } if params == true
   params
 end

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

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
 # create particles
-new({ particle: :markers, type: :hash })
+new({ particle: :markers, category: :time, type: :hash })

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-new({ particle: :renderers })
-new({ particle: :code })
-new({ particle: :run }) do |params|
+new({ particle: :renderers, category: :utility, type: :string })
+new({ particle: :code, category: :utility, type: :string })
+new({ particle: :run, category: :utility, type: :boolean }) do |params|
   code_found = @code
   instance_exec(params, &code_found) if code_found.is_a?(Proc)
 end
@@ -24,7 +24,7 @@ def delete_recursive(atome_id)
   Universe.delete(atome_id)
 end
 
-new({ particle: :delete, render: false }) do |params|
+new({ particle: :delete, category: :utility, type: :boolean, render: false }) do |params|
   if params == true
     # We use the tag persistent to exclude color of system object and other default colors
     unless @tag && (@tag[:persistent] || @tag[:system])
@@ -63,7 +63,7 @@ new({ particle: :delete, render: false }) do |params|
     send(params, 0) unless params == :id
   end
 end
-new({ particle: :clear })
+new({ particle: :clear, category: :utility, type: :boolean })
 
 new({ post: :clear }) do
   attached_found = []
@@ -76,8 +76,8 @@ new({ post: :clear }) do
     child_found&.delete(true) unless child_found.tag && child_found.tag[:system]
   end
 end
-new({ particle: :path })
-new({ particle: :schedule }) do |date, proc|
+new({ particle: :path, category: :utility, type: :string })
+new({ particle: :schedule, category: :utility, type: :string }) do |date, proc|
   date = date.to_s
   delimiters = [',', ' ', ':', '-']
   format_date = date.split(Regexp.union(delimiters))
@@ -85,14 +85,14 @@ new({ particle: :schedule }) do |date, proc|
     send("#{renderer}_schedule", format_date, &proc)
   end
 end
-new({ particle: :read }) do |file, proc|
-  Universe.renderer_list.each do |renderer|
-    send("#{renderer}_reader", file, &proc)
-  end
-end
-new({ particle: :cursor })
+# new({ particle: :read, category: :utility, type: :string }) do |file, proc|
+#   Universe.renderer_list.each do |renderer|
+#     send("#{renderer}_reader", file, &proc)
+#   end
+# end
+new({ particle: :cursor, category: :utility, type: :string })
 
-new({ particle: :preset }) do |params|
+new({ particle: :preset, category: :utility, type: :string }) do |params|
 
   if params.instance_of? Hash
     Essentials.new_default_params(params)
@@ -109,24 +109,26 @@ new({ particle: :preset }) do |params|
   end
   params_to_send
 end
-new({ particle: :relations, type: :hash })
-new({ particle: :tag, render: false, type: :hash })
-new({ particle: :web })
+new({ particle: :relations, category: :utility, type: :hash })
+new({ particle: :tag, render: false, category: :utility, type: :hash })
+new({ particle: :web, category: :utility, type: :string })
 # new({ particle: :metrics, type: :hash })
+# do not change the line below initialise is a special method
 new({ initialize: :unit, value: {} })
-new({ particle: :login }) do |params|
+
+new({ particle: :login, category: :utility, type: :string }) do |params|
   set_current_user(id) if params
 end
-new({ particle: :hypertext })
-new({ particle: :hyperedit })
-new({ particle: :terminal })
-new({ particle: :read })
-new({ particle: :browse })
-new({ particle: :copies })
-new({ particle: :temporary })
-new({ particle: :atomes })
+new({ particle: :hypertext, category: :utility, type: :string })
+new({ particle: :hyperedit, category: :utility, type: :string })
+new({ particle: :terminal, category: :utility, type: :string })
+new({ particle: :read, category: :utility, type: :string })
+new({ particle: :browse, category: :utility, type: :string })
+new({ particle: :copies, category: :utility, type: :string})
+new({ particle: :temporary, category: :utility, type: :int })
+new({ particle: :atomes, category: :utility, type: :string })
 
-new({ particle: :match }) do |params, _bloc|
+new({ particle: :match, category: :utility, type: :string }) do |params, _bloc|
   params
 end
 
@@ -135,10 +137,10 @@ new({ sanitizer: :match }) do |params, _bloc|
   params
 end
 
-new({ particle: :invert })
-new({ particle: :option })
+new({ particle: :invert, category: :utility, type: :boolean })
+new({ particle: :option, category: :utility, type: :string })
 
-new({ particle: :duplicate, store: false }) do |params|
+new({ particle: :duplicate, category: :utility, type: :string, store: false }) do |params|
   copy_number = if @duplicate
                   @duplicate.length
                 else
@@ -192,12 +194,12 @@ new({ after: :duplicate }) do |params|
   @duplicate[@duplicate.keys[@duplicate.keys.length - 1]]
 end
 
-new({ particle: :copy }) do |items_id|
+new({ particle: :copy, category: :utility, type: :string }) do |items_id|
   items_id = [items_id] unless items_id.instance_of? Array
   grab(:copy).collect << items_id
 end
 
-new({ particle: :paste }) do |params|
+new({ particle: :paste, category: :utility, type: :string }) do |params|
 
   all_copies = grab(:copy).collect
   if params == true
@@ -227,25 +229,25 @@ new({ read: :paste }) do |p|
   @copy
 end
 
-new({ particle: :backup })
+new({ particle: :backup, category: :utility, type: :string })
 
-new({ particle: :import })
+new({ particle: :import, category: :utility, type: :string })
 
-new({ particle: :compute }) do |params|
+new({ particle: :compute, category: :utility, type: :string }) do |params|
   params = { particle: params } unless params.instance_of?(Hash)
   params[:unit] ||= :pixel
   params[:reference] ||= :view
   params
 end
 
-new({ particle: :get }) do |params|
+new({ particle: :get, category: :utility, type: :string }) do |params|
   cell = params[:cell]
   row_nb = cell[0]
   column_nb = cell[1]
   data[row_nb][data[row_nb].keys[column_nb]] # we get the content of the cell
 end
 
-new ({ particle: :css })
+new ({ particle: :css, category: :utility, type: :string })
 
 new({ read: :css }) do
   CssProxy.new(js, nil, self)

data/lib/atome/genesis/genesis.rb

@@ -12,6 +12,7 @@ class Genesis
 
     def build_particle(particle_name, options = {}, &particle_proc)
       type = options[:type]
+      category = options[:category]
       type = :string if options[:type].nil?
       store = options[:store]
       store = true if options[:store].nil?
@@ -19,7 +20,7 @@ class Genesis
       render = true if options[:render].nil?
 
       # we add the new method to the particle's collection of methods
-      Universe.add_to_particle_list(particle_name, type)
+      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)

data/lib/atome/genesis/sparkle.rb

@@ -46,12 +46,12 @@ Atome.new(
 
 Atome.new(
   { renderers: default_render, id: :back_selection, type: :color, tag: ({ system: true, persistent: true }),
-    red: 0.6, green: 0.6, blue: 0.1, alpha: 0.7}
+    red: 0.6, green: 0.6, blue: 0.1, alpha: 0.7 }
 )
 
 Atome.new(
   { renderers: default_render, id: :text_selection, type: :color, tag: ({ system: true, persistent: true }),
-    red: 0.3, green: 0.3, blue: 0.3, alpha: 0.9}
+    red: 0.3, green: 0.3, blue: 0.3, alpha: 0.9 }
 )
 
 # system object creation
@@ -72,7 +72,7 @@ Atome.new(
 # unreal port, hold system object and tools
 Atome.new(
   { renderers: default_render, id: :intuition, type: :shape, attach: :user_view, tag: { system: true },
-    left: 0, top: 0, bottom: 0,width: 0, height: :auto, overflow: :visible
+    left: 0, top: 0, bottom: 0, width: 0, height: :auto, overflow: :visible
   }
 )
 
@@ -83,15 +83,14 @@ machine_password = { read: { atome: :star_wars }, write: { atome: :star_wars } }
 # copy basket
 Atome.new({ renderers: [:html], id: :copy, collect: [], type: :group, tag: { system: true } })
 
-
-#machine
+# machine
 Atome.new({ renderers: default_render, id: machine_id, type: :machine, password: machine_password,
             name: :macAir, data: { date: '10090717' }, tag: { system: true } })
 
-#user
-user_password = {global: :star_win, read: { atome: :star_wars }, write: { atome: :star_wars } }
+# user
+user_password = { global: :star_win, read: { atome: :star_wars }, write: { atome: :star_wars } }
 
-human({ id: :anonymous, login: true, password: user_password, data: { birthday: '10/05/1996' },selection: [],  attach: :user_view })
+human({ id: :anonymous, login: true, password: user_password, data: { birthday: '10/05/1996' }, selection: [], attach: :user_view })
 
 Universe.current_machine = machine_id
 # the constant A is used to access alla atomes methods
@@ -116,7 +115,6 @@ def atome_infos
   puts "server: #{server}"
 end
 
-
 # help and example below :
 #
 A.example(:left) do
@@ -139,5 +137,27 @@ STR
   end
 end
 
-# we init server default address now initialise in index.html for server
-# A.server({ address: 'localhost:9292' , type: 'ws'})
+# the method below init the user
+def atome_genesis
+  atome_infos
+  A.server({ address: 'localhost:9292', type: 'ws' })
+  A.init_websocket
+end
+
+def init_database # this method is call from JS (atome/communication)
+
+  particles = Universe.particle_list
+  categories = Universe.categories
+  atomes = Universe.atomes
+  # particles.each do |particle, value|
+  #   value[:category] = :undefined if value[:category].nil?
+  #   A.message({ action: :init_db, particle: particle, type: value[:type], category: value[:category] })
+  # end
+end
+
+def user_login
+  user = Universe.current_user
+  pass = Black_matter.password
+  message({ action: :login, value: user })
+  message({ action: :pass, value: pass })
+end

data/lib/atome/helpers/utilities.rb

@@ -19,34 +19,37 @@ class Atome
       JS.eval(js_command)
     end
 
-    # def global_monitoring(instance, methods_to_monitor, variables_to_monitor)
-    #   methods_to_monitor.each do |methode|
-    #     original_method = instance.method(methode)
-    #     instance.define_singleton_method(methode) do |*args, &block|
-    #       value_before = instance.instance_variable_get("@#{methode}")
-    #       result = original_method.call(*args, &block)
-    #       value_after = instance.instance_variable_get("@#{methode}")
-    #       if args.empty?
-    #         # "read monitoring: #{methode}"
-    #       elsif value_before != value_after
-    #         affect.each do |targeted_atome|
-    #           # get the content of the affect instance_variable and send it
-    #           # to the affect method to apply the atome to all atome children
-    #           grab(targeted_atome).render(:apply, self)
-    #         end
-    #       end
-    #       result
-    #     end
-    #   end
-    #   variables_to_monitor.each do |var|
-    #     instance.define_singleton_method(var) do
-    #       instance_variable_get("@#{var}")
-    #     end
-    #     instance.define_singleton_method("#{var}=") do |value|
-    #       instance_variable_set("@#{var}", value)
-    #     end
-    #   end
-    # end
+    # monitoring system
+    def monitoring(atomes_to_monitor, particles_to_monitor, &bloc)
+      atomes_to_monitor.each do |atome_to_monitor|
+        particles_to_monitor.each do |monitored_particle|
+          # Store original method
+          original_method = atome_to_monitor.method(monitored_particle)
+
+          # redefine method
+          atome_to_monitor.define_singleton_method(monitored_particle) do |*args, &proc|
+
+            # Monitor before calling original method
+            value_before = atome_to_monitor.instance_variable_get("@#{monitored_particle}")
+            if args.empty?
+              args = nil
+            else
+              if monitored_particle == :touch
+                instance_variable_set("@#{monitored_particle}", { tap: args[0] })
+                instance_variable_set("@#{monitored_particle}_code", { touch: proc })
+
+                args = { tap: args[0] }
+              else
+                instance_variable_set("@#{monitored_particle}", args[0])
+              end
+              args = args[0]
+            end
+            instance_exec({ original: value_before, altered: args, particle: monitored_particle }, &bloc) if bloc.is_a?(Proc)
+            original_method.call(*args)
+          end
+        end
+      end
+    end
 
   end
 
@@ -203,39 +206,73 @@ class Atome
     # FIXME : find a better algorithm can be found to avoid test if option is a Hash
     Object.attr_accessor "#{element}_code"
     elem_code = "@#{element}_code"
-    if params.instance_of? Hash
-      option_found = params.values[0]
-      instance_variable_get(elem_code)["#{option_found}_code"] = user_proc
-    else
+    # if params.instance_of? Hash
+    #   option_found = params.values[0]
+    #   instance_variable_get(elem_code)["#{option_found}_code"] = user_proc
+    # else
       instance_variable_get(elem_code)[element] = user_proc
-    end
-    # the commented line below will automatically execute the callback method
-    # we keep it commented because sometime the execution is conditioned, ex : run callbck on a touch
-    # send("#{element}_callback")
+    # end
   end
 
-  # this method is used to automatically create a callback method  sufifxed par '_callbback' ex :.shell => shell_callback
+  # ###################### new 1
+  # def store_proc(element, params = true, &user_proc)
+  #   instance_variable_set("@#{element}_code", {}) unless instance_variable_get("@#{element}_code")
+  #   # TODO : we may have to change this code if we need multiple proc for an particle
+  #   # FIXME : find a better algorithm can be found to avoid test if option is a Hash
+  #   Object.attr_accessor "#{element}_code"
+  #   elem_code = "@#{element}_code"
+  #   if params.instance_of? Hash
+  #     option_found = params.values[0]
+  #     puts "#{instance_variable_get(elem_code)["#{option_found}_code"]}"
+  #     proc_stored= instance_variable_get(elem_code)["#{option_found}_code"] = []
+  #     # proc_stored=[]
+  #   else
+  #     proc_stored= instance_variable_get(elem_code)[element] = []
+  #   end
+  #   proc_stored << user_proc
+  #   # the commented line below will automatically execute the callback method
+  #   # we keep it commented because sometime the execution is conditioned, ex : run callbck on a touch
+  #   # send("#{element}_callback")
+  # end
+  # ##################### new 1
+
+  # This method is used to automatically create a callback method suffixed by '_callback'. For example: shell => shell_callback.
   # it can be override if you create a method like:
   # new({callback: :shell}) do |params, bloc|
   # # …write what you want …
   # end
   def particle_callback(element)
-    Atome.define_method "#{element}_callback" do
-      proc_found = instance_variable_get("@#{element}_code")[element]
-      # instance_exec(@callback[element], proc_found)if proc_found.is_a? Proc
-      proc_found.call(@callback[element]) if proc_found.is_a? Proc
+    Atome.define_method("#{element}_callback") do |return_params|
+      # we test if instance_variable_get("@#{element}_code") is a hash for the can se the particle value is a hash
+      proc_found = if instance_variable_get("@#{element}_code").instance_of? Hash
+                     # Then we get the first item of the hash because the proc is attached to it
+                     instance_variable_get("@#{element}_code").values.first
+                     # instance_exec(@callback[element], proc_found)if proc_found.is_a? Proc
+                   else
+                     instance_variable_get("@#{element}_code")[element]
+                     # instance_exec(@callback[element], proc_found)if proc_found.is_a? Proc
+                            end
+      # array_of_proc_found.each do |proc_found|
+        proc_found.call(return_params) if proc_found.is_a? Proc
+      # end if array_of_proc_found
+
+      # if array_of_proc_found
+      #   proc_found= array_of_proc_found.shift
+      #   proc_found.call(return_params) if proc_found.is_a? Proc
+      # end
+
     end
   end
 
   # this method generate the method accessible for end developers
   # it's the send the method define in "particle_callback"
-  def call(element)
-    send("#{element}_callback")
+  def callback(element, return_params = nil)
+    send("#{element}_callback", return_params)
   end
 
-  def callback(data)
-    @callback[data.keys[0]] = data[data.keys[0]]
-  end
+  # def callback(data)
+  #   @callback[data.keys[0]] = data[data.keys[0]]
+  # end
 
   def particles(particles_found = nil)
     if particles_found
@@ -341,15 +378,37 @@ class Atome
     else
       @current_server
     end
+  end
 
+  def server_receiver(params)
+    # alert params
+    # alert message_code
+    calllbacks_found= instance_variable_get('@message_code')
+    # we delete the default message created by atome
+    calllbacks_found.delete(:message)
+    # we get the oldest available callback, to treat it
+    oldest_callback = calllbacks_found.delete(calllbacks_found.keys.first)
+    params=params[:return] #TODO : format retrun data correctly instead of this line
+    oldest_callback.call(params) if oldest_callback.is_a? Proc
+    # callback(:message, params)
   end
 
   def init_websocket
-    connection(server)
+    instance_variable_set('@message_code', {})
+    # connection is particle (communication.rb)
+    connection(@current_server)
   end
 
-  def init_database # this method is call from JS (atome/communication)
-    message({action:  :init_db, value: {atome: {}, particles: {}} })
+
+
+  def encrypt(string)
+    # if RUBY_ENGINE.downcase == 'opal' || 'wasm32-wasi'
+    # `sha256(#{string})`
+    js_code = "sha256('#{string}')"
+    JS.eval(js_code)
+    # else
+    # Digest::SHA256.hexdigest(string)
+    # end
   end
 end
 

data/lib/atome/kernel/universe.rb

@@ -9,6 +9,9 @@ class Universe
   @renderer_list = %i[html browser headless server log]
   @sanitizers = {}
   @specificities = {}
+
+  @categories = %w[ communication effect event geometry hierarchy identity material
+                  property security spatial time utility ]
   @history = {}
   @users = {}
   @help = {}
@@ -33,8 +36,12 @@ class Universe
       @example[particle]
     end
 
-    def add_to_particle_list(particle = nil, type)
-      instance_variable_get('@particle_list')[particle] = type
+    def categories
+      @categories
+    end
+
+    def add_to_particle_list(particle = nil, type, category)
+      instance_variable_get('@particle_list')[particle] = { type: type, category: category }
     end
 
     def add_atomes_specificities atome_type_to_add
@@ -78,9 +85,7 @@ class Universe
     def user_atomes
       collected_id = []
       @atomes.each do |id_found, atome_found|
-        unless atome_found.tag && atome_found.tag[:system]
-          collected_id << id_found
-        end
+        collected_id << id_found unless atome_found.tag && atome_found.tag[:system]
       end
       collected_id
     end
@@ -88,9 +93,7 @@ class Universe
     def system_atomes
       collected_id = []
       @atomes.each do |id_found, atome_found|
-        if atome_found.tag && atome_found.tag[:system]
-          collected_id << id_found
-        end
+        collected_id << id_found if atome_found.tag && atome_found.tag[:system]
       end
       collected_id
     end
@@ -153,7 +156,8 @@ class Universe
     end
 
     def current_server
-      return unless RUBY_ENGINE.downcase == 'opal' # Remplacez 'atome' par la valeur correcte pour votre environnement Atome
+      # Remplacez 'atome' par la valeur correcte pour votre environnement Atome
+      return unless RUBY_ENGINE.downcase == 'opal'
       JS.global[:location][:href].to_s
 
     end

data/lib/atome/version.rb

@@ -2,6 +2,6 @@
 
 #  return atome version
 class Atome
-  VERSION =   '0.5.6.1.4'
+  VERSION =    '0.5.6.2.0'
 end
 

data/lib/eVe/eVe.rb

@@ -1 +1 @@
-puts "so cool!!!"
+puts "eVe ready!!"

data/lib/eVe/eVe_relative.rb

@@ -1 +1 @@
-puts "so good!!!"
+puts "eve initialised"