atome 0.5.6.2.0 → 0.5.6.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc8ade696d1fa0d4ebc29a7ffbb336e1537d1f2b5c83c7772a6651f2b4558d0d
-  data.tar.gz: 0b849380beee8851a6e3571bb4f9df756524b0dab2746e146c5f35dc1b545ea3
+  metadata.gz: 02c478a58bfcce998a040779efdc8970c38a1d5286f8ca942231132493707f7d
+  data.tar.gz: 930ebabe49f5824c66e03b3b1b8b53e1def6ad0ce26ff40f2110c07461970f8b
 SHA512:
-  metadata.gz: 16319a956d2d2221eeb0b19ad60c305e811ae2fdec974e99ec33db58f6d1a11e3d71ea08bd73c1cfae4fb19c81aa3170c39ba64435fa155054bdea212e9bc908
-  data.tar.gz: 01df5f2b3923c04e05028ba711b9c83fdf431755685507dab92072eba959b1ee37e50a14dfe0c373f55f277def9c349e41fe76727f4b9828fcda389cc345b4f9
+  metadata.gz: 9161e9c2364dd6eb8e85d44d93872ea43f52e241a19aac7f1f4697890b1d638faa0891a94e85d917a2f8e4e75e5e322170e1bbfab1223ea0d26c1ee32ee33797
+  data.tar.gz: 2136de3b80e45cff68ad2c0345baf11d2565473f591c27261c6f2942414ca5d4442338597ee4d29936bb306e707846da991337cd915535a2dce705fd6dc1756a

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

@@ -10,10 +10,12 @@ new({ particle: :message, category: :communication, type: :hash }) do |params, b
   params = { data: params } unless params.instance_of? Hash
   params[:user] = 'dfghg4df5gdfgh654'
   params[:pass] = 'gfhkzrhgzr4h98948'
- instance_variable_set('@message_code', {}) unless instance_variable_get('@message_code')
-  store_proc= instance_variable_get('@message_code')
-  mmessage_id= "msg_#{store_proc.length}"
-  store_proc[mmessage_id]=bloc
+ # instance_variable_set('@message_code', {}) unless instance_variable_get('@message_code')
+ #  store_proc= instance_variable_get('@message_code')
+  message_id= "msg_#{Universe.messages.length}"
+   params[:message_id]=message_id
+ #  store_proc[mmessage_id]=bloc
+  Universe.store_messages({msg_nb:message_id, proc: bloc })
   html.send_message(params)
 
 end

data/lib/atome/genesis/sparkle.rb

@@ -141,7 +141,9 @@ end
 def atome_genesis
   atome_infos
   A.server({ address: 'localhost:9292', type: 'ws' })
-  A.init_websocket
+  A.init_websocket do |msg|
+    puts "-3 #{msg}"
+  end
 end
 
 def init_database # this method is call from JS (atome/communication)
@@ -149,6 +151,7 @@ def init_database # this method is call from JS (atome/communication)
   particles = Universe.particle_list
   categories = Universe.categories
   atomes = Universe.atomes
+  puts "we are here!!"
   # 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] })
@@ -156,8 +159,12 @@ def init_database # this method is call from JS (atome/communication)
 end
 
 def user_login
-  user = Universe.current_user
-  pass = Black_matter.password
-  message({ action: :login, value: user })
-  message({ action: :pass, value: pass })
+  # user = Universe.current_user
+  password = Black_matter.password
+  message({ action: :authentication, data: { email: 'jeezs@atome.one' } }) do |email|
+    puts "email received : #{email}"
+  end
+  message({ action: :authorization, data: { password: password } }) do |p|
+    puts "2 : #{p}"
+  end
 end

data/lib/atome/helpers/utilities.rb

@@ -177,13 +177,13 @@ class Atome
     new_atome
   end
 
-  def store(params)
-    params.each do |particle_to_save, data|
-      # @!atome[particle_to_save]=data
-      # instance_variable_set(particle_to_save,data)
-    end
-
-  end
+  # def store(params)
+  #   params.each do |particle_to_save, data|
+  #     # @!atome[particle_to_save]=data
+  #     # instance_variable_set(particle_to_save,data)
+  #   end
+  #
+  # end
 
   def history(filter = {})
     filter[:id] = @id
@@ -210,7 +210,7 @@ class Atome
     #   option_found = params.values[0]
     #   instance_variable_get(elem_code)["#{option_found}_code"] = user_proc
     # else
-      instance_variable_get(elem_code)[element] = user_proc
+    instance_variable_get(elem_code)[element] = user_proc
     # end
   end
 
@@ -251,9 +251,9 @@ class Atome
                    else
                      instance_variable_get("@#{element}_code")[element]
                      # instance_exec(@callback[element], proc_found)if proc_found.is_a? Proc
-                            end
+                   end
       # array_of_proc_found.each do |proc_found|
-        proc_found.call(return_params) if proc_found.is_a? Proc
+      proc_found.call(return_params) if proc_found.is_a? Proc
       # end if array_of_proc_found
 
       # if array_of_proc_found
@@ -381,26 +381,14 @@ class Atome
   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)
+    callback_found = Universe.messages[params[:message_id]]
+    callback_found.call(params) if callback_found.is_a? Proc
   end
 
   def init_websocket
-    instance_variable_set('@message_code', {})
-    # connection is particle (communication.rb)
     connection(@current_server)
   end
 
-
-
   def encrypt(string)
     # if RUBY_ENGINE.downcase == 'opal' || 'wasm32-wasi'
     # `sha256(#{string})`

data/lib/atome/kernel/universe.rb

@@ -9,6 +9,7 @@ class Universe
   @renderer_list = %i[html browser headless server log]
   @sanitizers = {}
   @specificities = {}
+  @messages = {}
 
   @categories = %w[ communication effect event geometry hierarchy identity material
                   property security spatial time utility ]
@@ -20,6 +21,18 @@ class Universe
   class << self
     attr_reader :atomes, :renderer_list, :atome_list, :particle_list, :classes, :counter, :atomes_specificities
 
+    def messages
+      @messages
+    end
+
+    def store_messages(new_msg)
+      @messages[new_msg[:msg_nb]] = new_msg[:proc]
+    end
+
+    def delete_messages(msg_to_del)
+      @messages.delete(msg_to_del)
+    end
+
     def set_help(particle, &doc)
       @help[particle] = doc
     end

data/lib/atome/version.rb

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

data/vendor/assets/application/examples/basic_understanding.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# The class Universe is used to  retrieve some data needed for the atome framework
+# The class Universe is used to retrieve some data needed for the atome framework
 # per example you can retrieve the list of all available particles
 puts Universe.particle_list
 # this give at the date 14/11/2023 :

data/vendor/assets/application/examples/database_handling.rb

@@ -1,23 +1,39 @@
-# # frozen_string_literal: true
-#
-A.message({ action: :insert, data: { table: :security, particle: :password, data: 'my_pass'} })
+# frozen_string_literal: true
+
+A.message({ action: :insert, data: { table: :security, particle: :password, data: 'my_pass'} }) do |datas|
+  puts "0 data received:  #{datas}"
+end
 
 A.message({ action: :insert, data: { table: :identity, particle: :name, data: 'jeezs' } }) do |data_received_from_server|
-  puts "my first insert #{data_received_from_server}"
+  puts "1 my first insert #{data_received_from_server}"
 end
 
+A.message({ action: :insert, data: { table: :identity, particle: :name, data: 'jeezs2' } })
+
 A.message({ action: :query, data: { table: :identity } }) do |data_received_from_server|
-  puts "another insert  : #{data_received_from_server}"
+  puts "2 another insert  : #{data_received_from_server}"
 end
 
 A.message({ action: :query, data: { table: :identity } }) do |data_received|
-  puts "received : #{data_received}"
+  puts "3 received : #{data_received}"
+end
+
+A.message({ action: :insert, data: { table: :identity, particle: :name, data: 'jeezs3' } }) do |result|
+  puts "4 insert done : #{result}"
+end
+
+A.message({ action: :insert, data: { table: :identity, particle: :name, data: 'jeezs4' } }) do |result|
+  puts "5 last message received: #{result}"
 end
 
-A.message({ action: :insert, data: { table: :identity, particle: :name, data: 'jeezs' } }) do |result|
-  puts "insert done : #{result}"
+A.message({ action: :insert, data: { table: :security, particle: :name, data: 'john doe' } }) do |data_received_from_server|
+  puts "6 test 1 : #{data_received_from_server}"
 end
 
-A.message({ action: :insert, data: { table: :identity, particle: :name, data: 'jeezs' } }) do |result|
-  puts "last message received: #{result}"
+A.message({ action: :insert, data: { table: :identity, particle: :tit, data: 'dummy' } }) do |data_received_from_server|
+  puts "7 test 2 :  #{data_received_from_server}"
 end
+
+A.message({ action: :insert, data: { table: :unknown, particle: :name, data: 'dummy2' } }) do |data_received_from_server|
+  puts "test 3 :  #{data_received_from_server}"
+end

data/vendor/assets/application/examples/server.rb

@@ -4,18 +4,21 @@ user_password = {global: :all_star, read: { atome: :all_star }, write: { atome:
 
 human({ id: :jeezs, login: true, password: user_password, data: { birthday: '10/05/2016' },selection: [], tag: { system: true } , attach: :user_view })
 
-
-
-
-
-
 c = box({ color: :yellow, left: 333 })
-
 c.touch(true) do
-  c.message({message: 'cd ..;cd server;ls; pwd', action: :terminal })
-  c.message({message: 'capture.rb', action: :file, option: :read })
-  c.message({message: 'tototo.rb', action: :file, option: :write, value: :hello })
-  # b.message({message: 'cd ..;cd server;ls; pwd'})
-  # c = box({ color: :red, left: 333 })
+  c.message({data: 'cd ..;cd server;ls; pwd', action: :terminal }) do |result|
+    puts "shell command return: #{result}"
+  end
+  c.message({data: {source: 'capture.rb',operation: :read  }, action: :file}) do |result|
+
+    puts "file read encoded_content: #{result[:data].gsub('\x23', '#')}"
+  end
+  c.message({ action: :file,data: {source: 'user_created_file.rb', operation: :write, value: :hello }})do |result|
+    puts "file creation result : #{result}"
+  end
+
+  A.message({ action: :terminal , data: 'cd ..;cd server;ls; pwd'}) do |result|
+    puts "result : #{result}"
+  end
 end
-
+#

data/vendor/assets/application/examples/test.rb

@@ -1,27 +1,6 @@
-# frozen_string_literal: true
+#  frozen_string_literal: true
 
-# If you need to specify another address for the server use A.server_adress
-A.server({ address: 'localhost:9292' , type: 'ws'})
-user_password = {global: :all_star, read: { atome: :all_star }, write: { atome: :all_star } }
-
-human({ id: :jeezs, login: true, password: user_password, data: { birthday: '10/05/2016' },selection: [], tag: { system: true } , attach: :user_view })
-
-
-#
-# b = box({ color: :red, id: :my_box })
-#
-# b.touch(true) do
-#   b.connection('localhost:9292') do |params|
-#     alert " the connection is : #{params}"
-#   end
-# end
-
-b = box({ color: :yellow, left: 333 })
-
-b.touch(true) do
-  b.message({message: 'cd ..;cd server;ls; pwd', action: :terminal })
-  b.message({message: 'capture.rb', action: :file, option: :read })
-  b.message({message: 'tototo.rb', action: :file, option: :write, value: :hello })
-  # b.message({message: 'cd ..;cd server;ls; pwd'})
-  # c = box({ color: :red, left: 333 })
-end
+my_pass = Black_matter.encode('hell')
+puts my_pass
+checker = Black_matter.check_password('hello,', my_pass)
+puts checker

data/vendor/assets/server/atome_server.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 # atome server
+
 require 'em/pure_ruby' if RUBY_PLATFORM == 'x64-mingw32'
 require 'fileutils'
 require '../src/utilities/aui'
@@ -14,341 +15,13 @@ require 'roda'
 require 'rufus-scheduler'
 require 'securerandom'
 require 'sequel'
-
-class EDen
-
-  def self.db_access
-    Database.connect_database
-  end
-
-  def self.terminal(cmd, option, ws, value, user, pass)
-    { return: `#{cmd}` }
-  end
-
-  def self.pass(cmd, option, ws, value, user, pass)
-    { return: 'pass received' }
-  end
-
-  def self.init_db(cmd, option, ws, value, user, pass)
-    # Database.
-    { return: 'database initialised' }
-  end
-
-  def self.query(cmd, option, ws, value, user, pass)
-    identity_table = db_access[cmd['table'].to_sym]
-    result = identity_table.send(:all).send(:select)
-    { action: :query, data: cmd['table'], return: result }
-  end
-
-  # def self.insert(cmd, option, ws, value, user, pass)
-  #   identity_table = db_access[:identity]
-  #   identity_table.insert(email: 'tre@tre')
-  #   { action: :insert, data: cmd, return: { email: 'tre@tre' } }
-  # end
-
-  def self.insert(params, option, ws, value, user, pass)
-    table = params['table']
-    particle = params['particle']
-    data = params['data']
-    identity_table = db_access[table.to_sym]
-    # identity_table = db_access[:identity]
-    #######
-    identity_table.insert(particle => data )
-      # identity_table.insert(email: 'tre@tre')
-    #
-    { return: "column : #{particle},  in table : #{table}, updated with : #{data}" }
-  end
-
-  # def self.authentification(cmd, option, ws, value, user, pass)
-  #   db = Database.connect_database
-  #   identity_items = db[:identity]
-  #   security_items = db[:security]
-  #
-  #   identity_items.insert(email: 'tre@tre')
-  #   security_items.insert(password: 'poipoi')
-  #   # testtest= "Mails count: #{identity_items.count}"
-  #
-  #   user_email = value["mail"]
-  #   user_password = value["pass"]
-  #
-  #   # user_exists = identity_items.all.select{|item| item[:email]==user_email}
-  #   user_exists = identity_items.send(:all).send(:select) do |item|
-  #     item[:email] == user_email
-  #   end
-  #
-  #   if user_exists.empty?
-  #     # "Mails count: #{identity_items.count}"
-  #     # "Mails count: #{identity_items.all}"
-  #     "Email non trouvé, erreur"
-  #     # Ask to the user if he wants to subscribe
-  #     # Send the basic template
-  #   else
-  #     "Email trouvé, cherche mdp"
-  #     # Verify password
-  #     # If password isn't ok, send error
-  #     # If the password is ok, send the user account template
-  #   end
-  # end
-
-  def self.file(source, operation, ws, value, user, pass)
-    file_content = File.send(operation, source, value).to_s
-    file_content = file_content.gsub("'", "\"")
-    { return: "=> operation: #{operation}, source:  #{source} , content : #{file_content}" }
-  end
-
-  # return_message = EDen.safe_send(action_requested, data,option, current_user, user_pass)
-
-  def self.safe_send(method_name, *args)
-    method_sym = method_name.to_sym
-    eden_methods = EDen.singleton_methods(false) - Object.singleton_methods
-    if eden_methods.include?(method_sym)
-      send(method_sym, *args)
-    else
-      { return: "forbidden action:  #{method_name}" }
-    end
-  end
-end
+require './eDen'
+require './database'
+require './extensions'
 
 Faye::WebSocket.load_adapter('puma')
 
-class String
-  def is_json?
-    begin
-      !JSON.parse(self).nil?
-    rescue
-      false
-    end
-  end
-end
-
-class Database
-
-  def self.table_exists?(table_name)
-    eden = Sequel.connect("sqlite://eden.sqlite3")
-    if eden.table_exists?(table_name)
-      puts "La table #{table_name} existe dans la base de données."
-    else
-      puts "La table suivante :  #{table_name} n'existe pas dans la base de données."
-    end
-
-  end
-
-  # def self.create_table(table_name)
-  def self.connect_database
-    if File.exist?("eden.sqlite3")
-      eden = Sequel.connect("sqlite://eden.sqlite3")
-      # now we test if the table exist
-      table_exists?(:table_name)
-    else
-      eden = Sequel.connect("sqlite://eden.sqlite3")
-      eden.create_table :atome do
-        primary_key :atome_id
-        String :creator
-      end
-
-      eden.create_table :communication do
-        primary_key :communication_id
-        String :connection
-        JSON :data
-        JSON :controller
-      end
-
-      ###################
-
-      Sequel.extension :migration
-
-      Sequel.migration do
-        change do
-          add_column :communication, :jesaispas, String
-        end
-      end.apply(eden, :up)
-
-      ###################
-
-      eden.create_table :effect do
-        primary_key :effect_id
-        Int :smooth
-        Int :blur
-      end
-
-      eden.create_table :event do
-        primary_key :event_id
-        JSON :touch
-        Boolean :play
-        Boolean :pause
-        Int :time
-        Boolean :on
-        Boolean :fullscreen
-        Boolean :mute
-        Boolean :drag
-        Boolean :drop
-        Boolean :over
-        String :targets
-        Boolean :start
-        Boolean :stop
-        Time :begin
-        Time :end
-        Int :duration
-        Int :mass
-        Int :damping
-        Int :stiffness
-        Int :velocity
-        Boolean :repeat
-        Boolean :ease
-        Boolean :keyboard
-        Boolean :resize
-        Boolean :overflow
-      end
-
-      eden.create_table :geometry do
-        primary_key :geometry_id
-        Int :width
-        Int :height
-        Int :size
-      end
-
-      eden.create_table :hierarchy do
-        primary_key :hierarchy_id
-        String :attach
-        String :attached
-        String :apply
-        String :affect
-        String :detached
-        String :collect
-      end
-
-      eden.create_table :identity do
-        primary_key :identity_id
-        String :real
-        String :type
-        Int :id
-        String :name
-        String :firstname
-        String :email
-        String :nickname
-        Boolean :active
-        String :markup
-        String :bundle
-        String :data
-        String :category
-        String :selection
-        Boolean :selected
-        String :format
-        String :alien
-      end
-
-      eden.create_table :material do
-        primary_key :material_id
-        String :component
-        Boolean :edit
-        String :style
-        Boolean :hide
-        Boolean :remove
-        JSON :classes
-        Boolean :remove_classes
-        Int :opacity
-        String :definition
-        Int :gradient
-        Int :border
-      end
-
-      eden.create_table :property do
-        primary_key :property_id
-        String :red
-        String :green
-        String :blue
-        String :alpha
-        String :diffusion
-        Boolean :clean
-        String :insert
-        Boolean :remove
-        Int :sort
-      end
-
-      eden.create_table :security do
-        primary_key :security_id
-        String :password
-      end
-
-      eden.create_table :spatial do
-        primary_key :spatial_id
-        Int :left
-        Int :right
-        Int :top
-        Int :bottom
-        Int :rotate
-        String :direction
-        String :center
-        Int :depth
-        Int :position
-        String :organise
-        String :spacing
-        Boolean :display
-        String :layout
-      end
-
-      eden.create_table :time do
-        primary_key :time_id
-        JSON :markers
-      end
-
-      eden.create_table :utility do
-        primary_key :utility_id
-        String :renderers
-        String :code
-        Boolean :run
-        Boolean :delete
-        Boolean :clear
-        String :path
-        String :schedule
-        String :read
-        String :cursor
-        String :preset
-        JSON :relations
-        JSON :tag
-        String :web
-        JSON :unit
-        String :initialize
-        String :login
-        String :hypertext
-        String :hyperedit
-        String :terminal
-        String :browse
-        String :copies
-        Int :temporary
-        String :atomes
-        String :match
-        Boolean :invert
-        String :option
-        String :duplicate
-        String :copy
-        String :paste
-        String :backup
-        String :import
-        String :compute
-        String :get
-      end
-
-    end
-    eden
-  end
-
-end
-
 class App < Roda
-
-  # comment below when test will be done
-  # File.delete("./eden.sqlite3") if File.exist?("./eden.sqlite3")
-  eden = Database.connect_database
-  items = eden[:atome]
-
-  # populate the table
-  items.insert(creator: 'moi')
-  items.insert(creator: 'toi')
-  items.insert(creator: 'vous')
-  puts "Item count: #{items.count}"
-  test = "Item count: #{items.count}"
-  # puts "My name is: #{items(:creator)}"
   index_content = File.read("../src/index_server.html")
   opts[:root] = '../src'
   plugin :static, %w[/css /js /medias], root: '../src'
@@ -356,34 +29,25 @@ class App < Roda
     r.root do
       if Faye::WebSocket.websocket?(r.env)
         ws = Faye::WebSocket.new(r.env)
-        ws.on :open do |event|
+        ws.on :open do |_event|
           ws.send({ return: 'server ready' }.to_json)
-          # ws.send('asking for synchro data'.to_json)
         end
-
         ws.on(:message) do |event|
           json_string = event.data.gsub(/(\w+):/) { "\"#{$1}\":" }.gsub('=>', ':')
           full_data = JSON.parse(json_string)
           data = full_data['data']
           action_requested = full_data['action']
-          value = full_data['value']
-          option = full_data['option']
-          current_user = full_data['user']
-          user_pass = full_data['pass']['global']
-          # return_message = EDen.safe_send(action_requested, data, option, ws, value, current_user, user_pass)
-          return_message = EDen.safe_send(action_requested, data, option, ws, value, current_user, user_pass)
+          message_id = full_data['message_id']
+          return_message = EDen.safe_send(action_requested, data, message_id)
           ws.send(return_message.to_json)
         end
-
         ws.on(:close) do |event|
           puts "server closed with status #{event.code}"
         end
         ws.rack_response
       end
-
       index_content
     end
-
   end
 
-end
+end

data/vendor/assets/server/database.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+# database handling for eDen Db
+
+class Database
+
+  def self.table_exists?(table_name)
+    eden = Sequel.connect("sqlite://eden.sqlite3")
+    if eden.table_exists?(table_name)
+      puts "La table #{table_name} existe dans la base de données."
+    else
+      puts "La table suivante :  #{table_name} n'existe pas dans la base de données."
+    end
+
+  end
+
+  # def self.create_table(table_name)
+  def self.connect_database
+    if File.exist?("eden.sqlite3")
+      eden = Sequel.connect("sqlite://eden.sqlite3")
+      # now we test if the table exist
+      table_exists?(:table_name)
+    else
+      eden = Sequel.connect("sqlite://eden.sqlite3")
+      eden.create_table :atome do
+        primary_key :atome_id
+        String :creator
+      end
+
+      eden.create_table :communication do
+        primary_key :communication_id
+        String :connection
+        JSON :data
+        JSON :controller
+      end
+
+      ###################
+
+      Sequel.extension :migration
+
+      Sequel.migration do
+        change do
+          add_column :communication, :jesaispas, String
+        end
+      end.apply(eden, :up)
+
+      ###################
+
+      eden.create_table :effect do
+        primary_key :effect_id
+        Int :smooth
+        Int :blur
+      end
+
+      eden.create_table :event do
+        primary_key :event_id
+        JSON :touch
+        Boolean :play
+        Boolean :pause
+        Int :time
+        Boolean :on
+        Boolean :fullscreen
+        Boolean :mute
+        Boolean :drag
+        Boolean :drop
+        Boolean :over
+        String :targets
+        Boolean :start
+        Boolean :stop
+        Time :begin
+        Time :end
+        Int :duration
+        Int :mass
+        Int :damping
+        Int :stiffness
+        Int :velocity
+        Boolean :repeat
+        Boolean :ease
+        Boolean :keyboard
+        Boolean :resize
+        Boolean :overflow
+      end
+
+      eden.create_table :geometry do
+        primary_key :geometry_id
+        Int :width
+        Int :height
+        Int :size
+      end
+
+      eden.create_table :hierarchy do
+        primary_key :hierarchy_id
+        String :attach
+        String :attached
+        String :apply
+        String :affect
+        String :detached
+        String :collect
+      end
+
+      eden.create_table :identity do
+        primary_key :identity_id
+        String :real
+        String :type
+        Int :id
+        String :name
+        String :firstname
+        String :email
+        String :nickname
+        Boolean :active
+        String :markup
+        String :bundle
+        String :data
+        String :category
+        String :selection
+        Boolean :selected
+        String :format
+        String :alien
+      end
+
+      eden.create_table :material do
+        primary_key :material_id
+        String :component
+        Boolean :edit
+        String :style
+        Boolean :hide
+        Boolean :remove
+        JSON :classes
+        Boolean :remove_classes
+        Int :opacity
+        String :definition
+        Int :gradient
+        Int :border
+      end
+
+      eden.create_table :property do
+        primary_key :property_id
+        String :red
+        String :green
+        String :blue
+        String :alpha
+        String :diffusion
+        Boolean :clean
+        String :insert
+        Boolean :remove
+        Int :sort
+      end
+
+      eden.create_table :security do
+        primary_key :security_id
+        String :password
+      end
+
+      eden.create_table :spatial do
+        primary_key :spatial_id
+        Int :left
+        Int :right
+        Int :top
+        Int :bottom
+        Int :rotate
+        String :direction
+        String :center
+        Int :depth
+        Int :position
+        String :organise
+        String :spacing
+        Boolean :display
+        String :layout
+      end
+
+      eden.create_table :time do
+        primary_key :time_id
+        JSON :markers
+      end
+
+      eden.create_table :utility do
+        primary_key :utility_id
+        String :renderers
+        String :code
+        Boolean :run
+        Boolean :delete
+        Boolean :clear
+        String :path
+        String :schedule
+        String :read
+        String :cursor
+        String :preset
+        JSON :relations
+        JSON :tag
+        String :web
+        JSON :unit
+        String :initialize
+        String :login
+        String :hypertext
+        String :hyperedit
+        String :terminal
+        String :browse
+        String :copies
+        Int :temporary
+        String :atomes
+        String :match
+        Boolean :invert
+        String :option
+        String :duplicate
+        String :copy
+        String :paste
+        String :backup
+        String :import
+        String :compute
+        String :get
+      end
+
+    end
+    eden
+  end
+
+end

data/vendor/assets/server/eDen.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# server utils to handle eDen Db
+
+class EDen
+
+  def self.db_access
+    Database.connect_database
+  end
+
+  def self.terminal(data, message_id)
+    { data: { message: `#{data}` }, message_id: message_id }
+  end
+
+  def self.authorization(_data, message_id)
+    { data: { message: 'password received'}, message_id: message_id }
+  end
+
+  def self.authentication(_data, message_id)
+    { data: { message: 'login received' }, message_id: message_id }
+  end
+
+  def self.init_db(_data, message_id)
+    { data: { message: 'database initialised' }, message_id: message_id }
+  end
+
+  def self.query(data, message_id)
+    identity_table = db_access[data['table'].to_sym]
+    result = identity_table.send(:all).send(:select)
+    { data: { table: data['table'], infos: result }, message_id: message_id }
+  end
+
+  def self.insert(data, message_id)
+    table = data['table'].to_sym
+    particle = data['particle'].to_sym
+    data = data['data']
+    if db_access.table_exists?(table)
+      schema = db_access.schema(table)
+      if schema.any? { |col_def| col_def.first == particle }
+        identity_table = db_access[table.to_sym]
+        identity_table.insert(particle => data)
+        { data: { message: "column : #{particle}, in table : #{table}, updated with : #{data}"}, message_id: message_id }
+      else
+        { data: { message: "column not found: #{particle.class}" }, message_id: message_id }
+      end
+    else
+      { data: { message: "table not found: #{table.class}" }, message_id: message_id }
+
+    end
+  end
+
+  def self.file(data, message_id)
+
+    file_content = File.send(data['operation'], data['source'], data['value']).to_s
+    file_content = file_content.gsub("'", "\"")
+
+    file_content = file_content.gsub('#', '\x23')
+    { data: "=> operation: #{data['operation']}, source: #{data['source']}, content: #{file_content}", message_id: message_id }
+  end
+
+  def self.safe_send(method_name, data, message_id)
+    method_sym = method_name.to_sym
+    send(method_sym, data, message_id)
+  end
+end

data/vendor/assets/server/extensions.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Object  extensions for atome
+
+class String
+  def is_json?
+    begin
+      !JSON.parse(self).nil?
+    rescue
+      false
+    end
+  end
+end

data/vendor/assets/src/js/atome/atome_helpers/communication.js

@@ -1,5 +1,4 @@
 const communication = {
-    // websocket: new WebSocket('ws://localhost:9292'),
     websocket: null,
     initialize: function () {
         this.websocket = new WebSocket('ws://localhost:9292')
@@ -10,9 +9,7 @@ const communication = {
         };
 
         this.websocket.onmessage = function (event) {
-            rubyVMCallback('message', "('" + event.data  + "')")
-
-            // rubyVMCallback("puts 'object ruby callback : " + event.data + "'")
+            rubyVMCallback('message', "('" + event.data + "')")
         };
 
         this.websocket.onclose = function (event) {
@@ -65,22 +62,16 @@ const communication = {
         }
     },
     connect: function (type, server, user, pass, atomes, particles) {
-        this.websocket = new WebSocket(type+'://'+server);
+        this.websocket = new WebSocket(type + '://' + server);
         this.websocket.onopen = function (event) {
 
-            // Opal.eval('A.init_database');
- // now new can exec user code : loadApplicationJs in index.html
- //            rubyVMCallback("A.init_database");
+            // now new can exec user code : loadApplicationJs in index.html
             loadApplicationJs();
             rubyVMCallback("A.user_login");
-            // rubyVMCallback("A.init_database");
         };
         this.websocket.onmessage = function (event) {
-            // rubyVMCallback("puts 'object ruby callback : " + event.data + "'")
-            // rubyVMCallback('message', "('" + event.data  + "')")
-            // rubyVMCallback("A.callback({ touch: '" + event.data  + "' })");
-            rubyVMCallback("A.server_receiver(" + event.data  + ")");
-            // alert(event.data)
+            // console.log(event.data)
+            rubyVMCallback("A.server_receiver(" + event.data + ")");
         };
 
         this.websocket.onclose = function (event) {
@@ -97,6 +88,7 @@ const communication = {
     },
     ws_sender: function (message) {
         // now we send the data to the server
+        // puts "--> message : #{message}"
         this.websocket.send(message)
     },
 }
@@ -130,8 +122,7 @@ const communication = {
 // }
 
 
-
-function controller_message(msg){
+function controller_message(msg) {
     // message receiver from controller (Vie)
     console.log(msg)
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atome
 version: !ruby/object:Gem::Version
-  version: 0.5.6.2.0
+  version: 0.5.6.2.3
 platform: ruby
 authors:
 - Jean-Eric Godard
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-12 00:00:00.000000000 Z
+date: 2024-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: artoo
@@ -622,6 +622,9 @@ files:
 - vendor/assets/server/atome_server_wasm.rb
 - vendor/assets/server/capture.rb
 - vendor/assets/server/config.ru
+- vendor/assets/server/database.rb
+- vendor/assets/server/eDen.rb
+- vendor/assets/server/extensions.rb
 - vendor/assets/src-tauri/.gitignore
 - vendor/assets/src-tauri/Cargo.toml
 - vendor/assets/src-tauri/build.rs