atome 0.5.6.2.3 → 0.5.6.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02c478a58bfcce998a040779efdc8970c38a1d5286f8ca942231132493707f7d
-  data.tar.gz: 930ebabe49f5824c66e03b3b1b8b53e1def6ad0ce26ff40f2110c07461970f8b
+  metadata.gz: 217af8e71c3443f96a514acb39e6b8aaf0b45ebdfe993ebe3dcf521bf4b0e2da
+  data.tar.gz: 3a3cd6668641eadc8261232a3eac694ff7ccdeeb8dc0cf176e930ca28f9c8114
 SHA512:
-  metadata.gz: 9161e9c2364dd6eb8e85d44d93872ea43f52e241a19aac7f1f4697890b1d638faa0891a94e85d917a2f8e4e75e5e322170e1bbfab1223ea0d26c1ee32ee33797
-  data.tar.gz: 2136de3b80e45cff68ad2c0345baf11d2565473f591c27261c6f2942414ca5d4442338597ee4d29936bb306e707846da991337cd915535a2dce705fd6dc1756a
+  metadata.gz: d20a7b73008b1af5d162ee08874de58af73e0c2d7e0fc4356f248997564d144e44207807a5ac03a240a72f58f57ba1fbbf6efda606aa2e1d5e43d441f11aa949
+  data.tar.gz: 5fff6175f1f55315119d56eba445a7b39b75954afcfa03cf5749da48d25fec6ad5fd85577c5a92bde5addc5da966cb78c4d06be7cf93d7627efffeb3ecc5ac96

data/lib/atome/extensions/atome.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
+module ObjectExtension
 
-# atome extensions
-class Object
   def new(params, &bloc)
     # Genesis = Genesis.Genesis
     if params.key?(:atome)
@@ -42,15 +41,69 @@ class Object
       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", option) do
-    #     alert option
-    #     bloc.call(option)
-    #   end
+      # elsif params.key?(:callback)
+      #   particle_targetted = params[:callback]
+      #   Atome.define_method("#{particle_targetted}_callback", option) do
+      #     alert option
+      #     bloc.call(option)
+      #   end
     end
+    super if defined?(super)
   end
 
+end
+# atome extensions
+class Object
+  include ObjectExtension
+  # def new(params, &bloc)
+  #   # Genesis = Genesis.Genesis
+  #   if params.key?(:atome)
+  #     if Universe.atome_list.include?(params[:atome])
+  #       puts "atome #{params[:atome]} already exist you can't create it"
+  #     else
+  #       Universe.add_atomes_specificities params[:atome]
+  #       Genesis.build_atome(params[:atome], &bloc)
+  #     end
+  #   elsif params.key?(:particle)
+  #     if Universe.particle_list[params[:particle]]
+  #       puts "particle #{params[:particle]} already exist you can't create it"
+  #     else
+  #       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
+  #       Genesis.build_particle(params[:particle], { render: params[:render], return: params[:return],
+  #                                                   store: params[:store], type: params[:type],
+  #                                                   category: params[:category] }, &bloc)
+  #     end
+  #
+  #   elsif params.key?(:sanitizer)
+  #     Genesis.build_sanitizer(params[:sanitizer], &bloc)
+  #   elsif params.key?(:pre)
+  #     Atome.instance_variable_set("@pre_#{params[:pre]}", bloc)
+  #   elsif params.key?(:post)
+  #     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", option) do
+  #   #     alert option
+  #   #     bloc.call(option)
+  #   #   end
+  #   end
+  # end
+
   def reorder_particles(hash_to_reorder)
     # we reorder the hash
     ordered_keys = %i[renderers id alien type attach int8 unit]

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

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

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

@@ -61,4 +61,6 @@ new(particle: :selected, category: :identity, type: :boolean) do |params|
 end
 
 new({ particle: :format, category: :identity, type: :string })
-new({ particle: :alien, category: :identity, type: :string }) #special particel that old alien object
+new({ particle: :alien, category: :identity, type: :string }) #special particel that old alien object
+
+new({ particle: :email, category: :identity, type: :string })

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

@@ -115,7 +115,14 @@ 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: :unit, store: false, type: :string, category: :utility }) do |params|
+  params.each do |k, v|
+    @unit[k] = v
+    # now we refresh the particle
+    send(k, send(k))
+  end
+  @unit
+end
 new({ particle: :login, category: :utility, type: :string }) do |params|
   set_current_user(id) if params
 end
@@ -124,7 +131,7 @@ 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: :copies, category: :utility, type: :string })
 new({ particle: :temporary, category: :utility, type: :int })
 new({ particle: :atomes, category: :utility, type: :string })
 

data/lib/atome/genesis/sparkle.rb

@@ -147,15 +147,33 @@ def atome_genesis
 end
 
 def init_database # this method is call from JS (atome/communication)
+  # we init the db file eDen
+  A.message({ action: :init_db, data: { database: :eDen } }) do |db_state|
+    puts db_state
+  end
 
   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] })
-  # end
+  categories.each do |category|
+    A.message({ action: :crate_db_table, data: { table: category } }) do |db_state|
+      puts db_state
+    end
+  end
+  particles_length=particles.length
+  particles.each_with_index do  |(particle, infos), index|
+    type = infos[:type]
+    table = infos[:category]
+    @i=1
+    A.message({ action: :create_db_column, data: { table: table, column: particle, type: type } }) do |db_state|
+      @i+=1
+      if @i==particles_length
+        user_login
+      end
+      puts db_state
+    end
+
+  end
+
 end
 
 def user_login
@@ -164,7 +182,7 @@ def user_login
   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}"
+  message({ action: :authorization, data: { password: password } }) do |pass|
+    puts "password recieved : #{pass}"
   end
 end

data/lib/atome/version.rb

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

data/lib/atome.rb

@@ -33,5 +33,5 @@ require 'renderers/html/index'
 require 'renderers/headless/index'
 require 'renderers/server/index'
 require 'atome/helpers/sanitizer'
-require 'eVe/eVe'
 require 'atome/genesis/sparkle'
+require 'eVe/eVe'

data/lib/atome_relative.rb

@@ -32,5 +32,6 @@ require_relative './renderers/html/index_relative'
 require_relative './renderers/headless/index_relative'
 require_relative './renderers/server/index_relative'
 require_relative './atome/helpers/sanitizer'
-require_relative './eVe/eVe_relative'
 require_relative './atome/genesis/sparkle'
+require_relative './eVe/eVe_relative'
+

data/lib/eVe/eVe.rb

@@ -1 +1,3 @@
-puts "eVe ready!!"
+# frozen_string_literal: true
+
+require 'eVe/lib/init'

data/lib/eVe/eVe_relative.rb

@@ -1 +1,3 @@
-puts "eve initialised"
+# frozen_string_literal: true
+
+require_relative './lib/init'

data/lib/eVe/lib/init.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module EveExtension
+  def new(params, &bloc)
+    if params[:page]
+      alert "alert salut"
+    elsif params[:application]
+      box({ left: 0, right: 0, width: :auto, top: 0, bottom: 0, height: :auto, id: :toto })
+    elsif params[:master]
+
+    end
+    super if defined?(super)
+  end
+end
+
+class Object
+  include EveExtension # Ajoutez d'abord les extensions de base
+end
+
+puts 'eVe ready'

data/lib/renderers/html/property.rb

@@ -51,11 +51,3 @@ new({ method: :sort, renderer: :html, type: :hash }) do |params|
   html.refresh_table(params)
 end
 
-new({ particle: :unit, store: false }) do |params|
-  params.each do |k, v|
-    @unit[k] = v
-    # now we refresh the particle
-    send(k, send(k))
-  end
-  @unit
-end

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

@@ -1,39 +1,39 @@
-# 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 "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 "2 another insert  : #{data_received_from_server}"
-end
-
-A.message({ action: :query, data: { table: :identity } }) do |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: :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: :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
+# # 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 "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 "2 another insert  : #{data_received_from_server}"
+# end
+#
+# A.message({ action: :query, data: { table: :identity } }) do |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: :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: :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/server/atome_server_wasm.rb

@@ -26,43 +26,43 @@ class String
   end
 end
 
-class Database
-  def self.connect_database
-    if File.exist?("eden.sqlite3")
-      eden = Sequel.connect("sqlite://eden.sqlite3")
-    else
-      eden = Sequel.connect("sqlite://eden.sqlite3")
-      eden.create_table :atome do
-        primary_key :atome_id
-        String :aui
-        String :id
-        String :type
-        String :name
-        String :content
-        String :position
-        String :dimension
-        String :color
-        String :right
-        String :effect
-        String :shadow
-        String :border
-        String :fill
-        Float :x
-        Float :xx
-        Float :y
-        Float :yy
-        Float :z
-        Float :zz
-        Float :width
-        Float :height
-        Float :depth
-      end
-
-    end
-    eden
-  end
-
-end
+# class Database
+#   def self.connect_database
+#     if File.exist?("eden.sqlite3")
+#       eden = Sequel.connect("sqlite://eden.sqlite3")
+#     else
+#       eden = Sequel.connect("sqlite://eden.sqlite3")
+#       eden.create_table :atome do
+#         primary_key :atome_id
+#         String :aui
+#         String :id
+#         String :type
+#         String :name
+#         String :content
+#         String :position
+#         String :dimension
+#         String :color
+#         String :right
+#         String :effect
+#         String :shadow
+#         String :border
+#         String :fill
+#         Float :x
+#         Float :xx
+#         Float :y
+#         Float :yy
+#         Float :z
+#         Float :zz
+#         Float :width
+#         Float :height
+#         Float :depth
+#       end
+#
+#     end
+#     eden
+#   end
+#
+# end
 
 class App < Roda
   # comment below when test will be done

data/vendor/assets/server/database.rb

@@ -1,217 +1,35 @@
 # frozen_string_literal: true
 
 # database handling for eDen Db
-
 class Database
+  class << self
+    Sequel.extension :migration
 
-  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."
+    def db_access
+      Sequel.connect("sqlite://eden.sqlite3")
     end
 
-  end
-
-  # def self.create_table(table_name)
-  def self.connect_database
-    if File.exist?("eden.sqlite3")
+    def create_table(table_name)
       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
+      unless eden.table_exists?(table_name)
+        eden.create_table table_name.to_sym do
+          primary_key "#{table_name}_id".to_sym
         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
+    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
+    def create_column(table, column_name, type)
+      eden = Sequel.connect("sqlite://eden.sqlite3")
+      if eden.table_exists?(table)
+        unless eden.schema(table).any? { |column| column.first == column_name }
+          Sequel.migration do
+            change do
+              add_column table, column_name, type
+            end
+          end.apply(eden, :up)
+        end
       end
-
     end
-    eden
   end
 
 end

data/vendor/assets/server/eDen.rb

@@ -3,63 +3,110 @@
 # server utils to handle eDen Db
 
 class EDen
+  class << self
+    def db_access
+      Database.db_access
+    end
 
-  def self.db_access
-    Database.connect_database
-  end
+    def terminal(data, message_id)
+      { data: { message: `#{data}` }, message_id: message_id }
+    end
 
-  def self.terminal(data, message_id)
-    { data: { message: `#{data}` }, message_id: message_id }
-  end
+    def authorization(data, message_id)
+      db = db_access
+      security_items = db[:security]
+      user_password = data["password"]
+      user_exists = security_items.where(password: user_password).first
 
-  def self.authorization(_data, message_id)
-    { data: { message: 'password received'}, message_id: message_id }
-  end
+      if !user_exists
+        { return: 'Password not found', message_id: message_id }
+        # Ask to the user if he wants to subscribe
+        # Send the basic template
+      else
+        { return: 'Password found, connected', message_id: message_id }
+        # Send the user account template
+      end
+    end
 
-  def self.authentication(_data, message_id)
-    { data: { message: 'login received' }, message_id: message_id }
-  end
+    def authentication(data, message_id)
+      # { data: { message: 'login received' }, message_id: message_id }
+      db = db_access
+      identity_items = db[:identity]
+      user_email = data["email"]
+      mail_exists = identity_items.where(email: user_email).first
 
-  def self.init_db(_data, message_id)
-    { data: { message: 'database initialised' }, message_id: message_id }
-  end
+      if !mail_exists
+        { return: 'Email not found', message_id: message_id }
+        # { return: user_email, message_id: message_id }
+        # Ask to the user if he wants to subscribe
+        # Send the basic template
+      else
+        { return: 'Email found, looking for pass', message_id: message_id }
+        # Verify password
+        # If password isn't ok, send error
+        # If the password is ok, send the user account template
+      end
+    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 init_db(_data, message_id)
+      unless File.exist?("eden.sqlite3")
+        Sequel.connect("sqlite://eden.sqlite3")
+      end
+      { data: { message: 'database initialised' }, message_id: message_id }
+    end
+
+    def crate_db_table(data, message_id)
+      table = data['table']
+      Database.create_table(table)
+      { data: { message: "table #{table} added" }, message_id: message_id }
+    end
+
+    def create_db_column(data, message_id)
+      table = data['table']
+      column = data['column']
+      type = data['type']
+      Database.create_column(table, column, type)
+      { data: { message: "column #{column} with type : #{type} added" }, message_id: message_id }
+    end
+
+    def 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 }
+    def 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: "column not found: #{particle.class}" }, message_id: message_id }
-      end
-    else
-      { data: { message: "table not found: #{table.class}" }, message_id: message_id }
+        { data: { message: "table not found: #{table.class}" }, message_id: message_id }
 
+      end
     end
-  end
 
-  def self.file(data, message_id)
+    def file(data, message_id)
 
-    file_content = File.send(data['operation'], data['source'], data['value']).to_s
-    file_content = file_content.gsub("'", "\"")
+      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
+      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)
+    def safe_send(method_name, data, message_id)
+      method_sym = method_name.to_sym
+      send(method_sym, data, message_id)
+    end
   end
+
 end

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

@@ -67,7 +67,7 @@ const communication = {
 
             // now new can exec user code : loadApplicationJs in index.html
             loadApplicationJs();
-            rubyVMCallback("A.user_login");
+            // rubyVMCallback("A.user_login");
         };
         this.websocket.onmessage = function (event) {
             // console.log(event.data)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atome
 version: !ruby/object:Gem::Version
-  version: 0.5.6.2.3
+  version: 0.5.6.2.5
 platform: ruby
 authors:
 - Jean-Eric Godard
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-14 00:00:00.000000000 Z
+date: 2024-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: artoo
@@ -465,6 +465,7 @@ files:
 - lib/eVe/documentation/server.md
 - lib/eVe/eVe.rb
 - lib/eVe/eVe_relative.rb
+- lib/eVe/lib/init.rb
 - lib/eVe/todo.txt
 - lib/platform_specific/opal/atome_opal_extensions.rb
 - lib/platform_specific/opal/extensions/color.rb