atome 0.5.6.1.4 → 0.5.6.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a515b71a46e24e1b7ea6a668c26ee2ece0c52fb9ddce21bb132b1e115245d35
-  data.tar.gz: 59552abb50bb72ac0320f7ea03fa702dfc9b5d65a356937c285ef154f90c342b
+  metadata.gz: cc8ade696d1fa0d4ebc29a7ffbb336e1537d1f2b5c83c7772a6651f2b4558d0d
+  data.tar.gz: 0b849380beee8851a6e3571bb4f9df756524b0dab2746e146c5f35dc1b545ea3
 SHA512:
-  metadata.gz: f58521a86e18da6d1313c629dd35d60f03776beee6f2cbcbe9c8676ab6a36986ecfade194814abef3d95407fa8bebbd067ed4d9787059bb0a7ac73ff1363d2f1
-  data.tar.gz: 86e9a462e19c7bdb62c834b5a08e98dee89f168cd7cb904cb34cd15a62e38bd385455eced957005f491d5d27f296f4f451a3c5ce6850a705448c46f0cda0b0d5
+  metadata.gz: 16319a956d2d2221eeb0b19ad60c305e811ae2fdec974e99ec33db58f6d1a11e3d71ea08bd73c1cfae4fb19c81aa3170c39ba64435fa155054bdea212e9bc908
+  data.tar.gz: 01df5f2b3923c04e05028ba711b9c83fdf431755685507dab92072eba959b1ee37e50a14dfe0c373f55f277def9c349e41fe76727f4b9828fcda389cc345b4f9

data/Rakefile

@@ -216,6 +216,50 @@ task :test_server do
   build_for_opal_server(destination, project_name, 9292, :production)
 end
 
+
+task :opal_server_rebuild do
+  project_name = :test
+  source = '.'
+  destination = './tmp'
+  script_source = './test/application'
+  create_application(source, destination, project_name)
+  # the line below is to add addition script to the application folder (useful for test per example)
+  add_to_application_folder(script_source, destination, project_name)
+  # build opal
+  build_opal_library(source, destination, project_name)
+  # build parser
+  build_opal_parser(source, destination, project_name)
+  # build atome kernel
+  build_atome_kernel_for_opal(source, destination, project_name)
+  # build host_mode
+  build_host_mode(destination, project_name, 'puma-roda')
+  # build Opal extensions
+  build_opal_extensions(source, destination, project_name)
+  # build application
+  build_opal_application(source, destination, project_name)
+  # build and open the app
+  threads = []
+  threads << Thread.new do
+
+    sleep 1
+    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+      # code to exec for Windows
+      `start  http://localhost:9292`
+      # `start #{destination}\\#{project_name}\\src\\index_server.html`
+
+    elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
+      # code to exec for MacOS
+      `open http://localhost:9292`
+    else
+      # code to exec for Unix/Linux
+      `open http://localhost:9292`
+    end
+
+  end
+
+  # build_for_opal_server(destination, project_name, 9292, :production)
+end
+
 task :test_osx do
   project_name = :test
   source = '.'

data/documentation/deep learning/basic_infos.txt

@@ -160,6 +160,9 @@ s.shape => ‘pwd’
 
 Callback :
 
+
+Important : all atome particle have a pros associated often use for callback when needed :
+to acces this code use "particle_name_code" ex for touch to access the callbacks use : touch_code
 s.shell(‘pwd’) do |method_return|
 	puts method_return
 end
@@ -281,3 +284,6 @@ in presets/atome, atome_common:
 
 
 
+atome expert and atome developers
+expert develop atome core
+developers create solution with atome framework

data/exe/atome

@@ -383,9 +383,7 @@ STR
     File.open("#{destination}/#{project_name}/server/config.ru", "w") do |f|
       f.write(ru_file)
     end
-    puts 'o-a'
     `cd #{destination}/#{project_name}/server;puma --port #{port} #{prod}`
-    puts 'o-b'
   else
     # code to exec with Unix/Linux
     File.open("#{destination}/#{project_name}/server/config.ru", "w") do |f|

data/lib/atome/atome.rb

@@ -11,7 +11,7 @@ class Atome
     # the keys :renderers, :type and :id should be placed in the first position in the hash
     @history = {}
     # @language = :english
-    @callback = {}
+    # @callback = {}
     @tag = {}
     @selected = false
     #@metrics = {}

data/lib/atome/extensions/atome.rb

@@ -5,15 +5,25 @@ class Object
   def new(params, &bloc)
     # Genesis = Genesis.Genesis
     if params.key?(:atome)
-      Universe.add_atomes_specificities params[:atome]
-      Genesis.build_atome(params[:atome], &bloc)
+      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)
-      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] }, &bloc)
+      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)
@@ -32,17 +42,18 @@ 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" do
-        bloc.call
-      end
+    # 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]
+    ordered_keys = %i[renderers id alien type attach int8 unit]
 
     ordered_part = ordered_keys.map { |k| [k, hash_to_reorder[k]] }.to_h
     other_part = hash_to_reorder.reject { |k, _| ordered_keys.include?(k) }
@@ -488,7 +499,7 @@ class Object
     else
       id_wanted = {}
     end
-    basis = { alien: params[:target],renderers: [:html],  type: :atomized }.merge(id_wanted)
+    basis = { alien: params[:target], renderers: [:html], type: :atomized }.merge(id_wanted)
     a = Atome.new(basis)
     return a
     # convert any foreign object (think HTML) to a pseudo atome objet , that embed foreign objet
@@ -496,17 +507,15 @@ class Object
 
 end
 
-
 class CssProxy
   def initialize(js, parent_key = nil, current_atome)
     @js = js
-    @css={}
+    @css = {}
     @parent_key = parent_key
     @style = {}
-    @current_atome=current_atome
+    @current_atome = current_atome
   end
 
-
   def [](key)
     if @parent_key
       @current_atome.instance_variable_get('@css')[@parent_key]&.[](key)
@@ -515,13 +524,11 @@ class CssProxy
     end
   end
 
-
-
   def []=(key, value)
     if @parent_key
       @js[@parent_key][key] = value
-      @current_atome.instance_variable_set('@css',{@parent_key => {key => value}})
-      @css[@parent_key]={key => value}
+      @current_atome.instance_variable_set('@css', { @parent_key => { key => value } })
+      @css[@parent_key] = { key => value }
       puts "==> Clé parente: #{@parent_key}, Clé: #{key}, Valeur: #{value}"
     else
       @style[key] = value
@@ -535,4 +542,7 @@ class CssProxy
     @current_atome.instance_variable_get('@css').to_s
   end
 
+
+
+
 end

data/lib/atome/extensions/sha.rb

@@ -1,8 +1,8 @@
-# frozen_string_literal: true
-
-# to create a hash
-class Atome
-  def calculate_sha(string)
-    Digest::SHA256.hexdigest(string)
-  end
-end
+# # frozen_string_literal: true
+#
+# # to create a hash
+# class Atome
+#   def calculate_sha(string)
+#     Digest::SHA256.hexdigest(string)
+#   end
+# end

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

@@ -96,7 +96,7 @@ new({ atome: :matrix })
 new({ atome: :atomized, type: :hash })
 
 # new({ atome: :color, type: :model })
-new({ atome: :color, type: :template })
+# new({ atome: :color, type: :template })
 
 
 

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

@@ -1,36 +1,30 @@
 # frozen_string_literal: true
 
-new({ particle: :connection }) do |params, bloc|
-  # params = { server: params }
-  # type = { server: params }
-  params[:user] = Universe.current_user
-  params[:pass] = Black_matter.password
-  params[:atomes] = Universe.atome_list
-  params[:particles] = Universe.particle_list
+new({ particle: :connection, category: :communication, type: :hash }) do |params, bloc|
+
   # FIXME :  html method shouldn't be here
   html.connect(params, &bloc)
-  # test below
-  # wait 1 do
-  #   message({message: 'cd ..;cd server;ls; pwd', action: :terminal })
-  # end
 end
 
-new({ particle: :message }) do |params, bloc|
-
-  params = { message: params } unless params.instance_of? Hash
-  params[:user] = Universe.current_user
-  params[:pass] = Black_matter.password
+new({ particle: :message, category: :communication, type: :hash }) do |params, bloc|
+  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
+  html.send_message(params)
 
-  html.send_message(params, &bloc)
 end
 
-new({ particle: :controller }) do |msg|
+new({ particle: :controller, category: :communication, type: :hash }) do |msg|
   Atome.controller_sender(msg)
 end
 
-new({ particle: :int8 })
+new({ particle: :int8, category: :communication, type: :int })
 
-new({ particle: :language }) do |params|
+new({ particle: :language, category: :communication, type: :string }) do |params|
   @data = int8[params]
   params
 end

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-new({ particle: :smooth })
+new({ particle: :smooth, category: :effect, type: :int })
 
 
-new({ particle: :blur }) do |params|
+new({ particle: :blur, category: :effect, type: :int }) do |params|
   # alert params
   { value: params, affect: :self } unless params.instance_of?(Hash)
   # params

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-new({ particle: :touch, type: :hash, store: false })
+new({ particle: :touch, category: :event, type: :hash, store: false })
 new({ sanitizer: :touch }) do |params, user_bloc|
   # TODO: factorise code below
   @touch ||= {}
@@ -44,7 +44,7 @@ new({ sanitizer: :touch }) do |params, user_bloc|
   params
 
 end
-new({ particle: :play, store: false })
+new({ particle: :play, category: :event, type: :boolean, store: false })
 new({ sanitizer: :play }) do |params, user_bloc|
   @play ||= {}
   @play_code ||= {}
@@ -78,9 +78,9 @@ new({ sanitizer: :play }) do |params, user_bloc|
 
   params
 end
-new({ particle: :pause })
-new({ particle: :time })
-new({ particle: :on, store: false })
+new({ particle: :pause, category: :event, type: :boolean })
+new({ particle: :time, category: :event, type: :int })
+new({ particle: :on, category: :event, type: :boolean, store: false })
 new({ sanitizer: :on }) do |params, user_bloc|
   @on ||= {}
   @on_code ||= {}
@@ -107,9 +107,9 @@ new({ sanitizer: :on }) do |params, user_bloc|
   @on[params] = option
   params
 end
-new({ particle: :fullscreen })
-new({ particle: :mute })
-new({ particle: :drag, store: false })
+new({ particle: :fullscreen, category: :event, type: :boolean })
+new({ particle: :mute, category: :event, type: :boolean })
+new({ particle: :drag, category: :event, type: :boolean, store: false })
 new({ sanitizer: :drag }) do |params, user_bloc|
   @drag ||= {}
   @drag_code ||= {}
@@ -156,7 +156,7 @@ new({ sanitizer: :drag }) do |params, user_bloc|
   @drag[params] = option
   params
 end
-new({ particle: :drop, store: false })
+new({ particle: :drop, category: :event, type: :boolean, store: false })
 new({ sanitizer: :drop }) do |params, user_bloc|
   @drop ||= {}
   @drop_code ||= {}
@@ -191,7 +191,7 @@ new({ sanitizer: :drop }) do |params, user_bloc|
   @drop[params] = option
   params
 end
-new({ particle: :over, type: :hash, store: false })
+new({ particle: :over, category: :event, type: :hash, store: false })
 new({ sanitizer: :over }) do |params, user_bloc|
 
   #  TODO: factorise code below
@@ -233,25 +233,25 @@ end
 #   @sort_proc = sort_proc
 # end
 
-new({ particle: :targets })
-new({ particle: :start })
+new({ particle: :targets, category: :event, type: :string })
+new({ particle: :start, category: :event, type: :boolean })
 new({ pre: :start }) do |_value, user_proc|
   @animation_start_proc = user_proc
 end
-new({ particle: :stop })
+new({ particle: :stop, category: :event, type: :boolean })
 new({ pre: :stop }) do |_value, user_proc|
   @animation_stop_proc = user_proc
 end
-new({ particle: :begin })
-new({ particle: :end })
-new({ particle: :duration })
-new({ particle: :mass })
-new({ particle: :damping })
-new({ particle: :stiffness })
-new({ particle: :velocity })
-new({ particle: :repeat })
-new({ particle: :ease })
-new(particle: :keyboard, type: :hash, store: false)
+new({ particle: :begin, category: :event, type: :time })
+new({ particle: :end, category: :event, type: :time })
+new({ particle: :duration, category: :event, type: :int })
+new({ particle: :mass, category: :event, type: :int })
+new({ particle: :damping, category: :event, type: :int })
+new({ particle: :stiffness, category: :event, type: :int })
+new({ particle: :velocity, category: :event, type: :int })
+new({ particle: :repeat, category: :event, type: :boolean })
+new({ particle: :ease, category: :event, type: :boolean })
+new(particle: :keyboard, category: :event, type: :hash, store: false)
 new({ sanitizer: :keyboard }) do |params, user_bloc|
   @keyboard ||= {}
   @keyboard_code ||= {}
@@ -289,7 +289,7 @@ new({ sanitizer: :keyboard }) do |params, user_bloc|
 
   params
 end
-new({ particle: :resize, store: false  })
+new({ particle: :resize, category: :event, type: :boolean, store: false  })
 new({ sanitizer: :resize }) do |params, user_bloc|
   @resize ||= { }
   @resize_code ||= {}
@@ -316,7 +316,7 @@ new({ sanitizer: :resize }) do |params, user_bloc|
 
   params
 end
-new({ particle: :overflow }) do |params, bloc|
+new({ particle: :overflow, category: :event, type: :boolean }) do |params, bloc|
   @overflow_code ||= {}
   instance_variable_get('@overflow_code')[:overflow] = bloc
   params

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-new({ particle: :width })
-new({ particle: :height })
+new({ particle: :width, category: :geometry, type: :int })
+new({ particle: :height, category: :geometry, type: :int })
 
-new({ particle: :size }) do |params|
+new({ particle: :size, category: :geometry, type: :int }) do |params|
   params = { value: params } unless params.instance_of? Hash
   params[:recursive] ||= false
   params[:reference] ||= :x

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

@@ -30,12 +30,12 @@ def attachment_common(child_id, parents_id, direction, &user_proc)
   end
 end
 
-new({ particle: :attach, render: false }) do |parents_id, &user_proc|
+new({ particle: :attach, category: :hierarchy, type: :string, render: false }) do |parents_id, &user_proc|
   attachment_common(@id, parents_id, :attach, &user_proc)
   parents_id
 end
 
-new({ particle: :attached, render: false }) do |children_ids, &user_proc|
+new({ particle: :attached, category: :hierarchy, type: :string, render: false }) do |children_ids, &user_proc|
   children_ids = [children_ids] unless children_ids.instance_of?(Array)
   parents_id = @id
   children_ids.each do |children_id|
@@ -48,7 +48,7 @@ new({ sanitizer: :attached }) do |children_ids|
   children_ids
 end
 
-new({ particle: :apply, render: false, store: false }) do |parents_ids, &user_proc|
+new({ particle: :apply, category: :hierarchy, type: :string, render: false, store: false }) do |parents_ids, &user_proc|
   # TODO: optimize the 2 lines below:
   @apply ||= []
   parents_ids = [parents_ids] unless parents_ids.instance_of?(Array)
@@ -77,7 +77,7 @@ new({ particle: :apply, render: false, store: false }) do |parents_ids, &user_pr
   parents_ids
 end
 
-new({ particle: :affect, render: false }) do |children_ids, &user_proc|
+new({ particle: :affect, category: :hierarchy, type: :string, render: false }) do |children_ids, &user_proc|
   children_ids = [children_ids] unless children_ids.instance_of? Array
   children_ids.each do |child_id|
     child_found = grab(child_id)
@@ -86,7 +86,7 @@ new({ particle: :affect, render: false }) do |children_ids, &user_proc|
   children_ids
 end
 
-new({ particle: :detached, store: false }) # unfastened
+new({ particle: :detached, category: :hierarchy, type: :string, store: false }) # unfastened
 new({ sanitizer: :detached }) do |values|
   # unfastened
   if values.instance_of? Array
@@ -100,4 +100,4 @@ new({ sanitizer: :detached }) do |values|
   end
   values
 end
-new({ particle: :collect })
+new({ particle: :collect, category: :hierarchy, type: :string })

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-new({ particle: :real })
-new({ particle: :type })
-new({ particle: :id })
+new({ particle: :real, category: :identity, type: :string })
+new({ particle: :type, category: :identity, type: :string })
+new({ particle: :id, category: :identity, type: :int })
 new({ sanitizer: :id }) do |params|
   # first we sanitize the the id below
   params = params.to_sym
@@ -13,8 +13,8 @@ new({ sanitizer: :id }) do |params|
   end
   params
 end
-new({ particle: :name })
-new({ particle: :active })
+new({ particle: :name, category: :identity, type: :string })
+new({ particle: :active, category: :identity, type: :boolean })
 # new({ particle: :entangled, type: :array })
 # new({ particle: :clones }) do |clones_found|
 #   clones_found.each_with_index do |clone_found, index|
@@ -30,18 +30,18 @@ new({ particle: :active })
 #     end
 #   end
 # end
-new({ particle: :markup })
-new({particle: :bundle})
-new({ particle: :data })
+new({ particle: :markup, category: :identity, type: :string })
+new({particle: :bundle, category: :identity, type: :string})
+new({ particle: :data, category: :identity, type: :string })
 
-new({particle: :category, store: false}) do |category_names|
+new({particle: :category, category: :identity, type: :string, store: false}) do |category_names|
   category_names=[category_names] unless category_names.instance_of? Array
   category_names.each do |category_name| 
     @category << category_name
   end
 end
 # The selection particle is used by current user to store selected atomes
-new(particle: :selection)
+new(particle: :selection, category: :identity, type: :string)
 
 new({ read: :selection }) do |params_get|
   selector = grab(:selector)
@@ -49,7 +49,7 @@ new({ read: :selection }) do |params_get|
   selector
 end
 
-new(particle: :selected) do |params|
+new(particle: :selected, category: :identity, type: :boolean) do |params|
   if params == true
     grab(Universe.current_user).selection << @id
   elsif params == false
@@ -60,5 +60,5 @@ new(particle: :selected) do |params|
   params
 end
 
-new({ particle: :format })
-new({ particle: :alien }) #special particel that old alien object
+new({ particle: :format, category: :identity, type: :string })
+new({ particle: :alien, category: :identity, type: :string }) #special particel that old alien object

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

@@ -1,17 +1,30 @@
 # frozen_string_literal: true
 
-new({ particle: :component })
+new({ particle: :component, category: :material, type: :string })
 
-new({ particle: :edit })
-new({ particle: :style })
+new({ particle: :edit, category: :material, type: :boolean })
+new({ particle: :style, category: :material, type: :string })
 new({ pre: :style }) do |styles_send, _user_proc|
   styles_send.each do |particle_send, value|
     send(particle_send, value)
   end
 end
-new({ particle: :hide })
+new({ particle: :hide, category: :material, type: :boolean })
 
-new({ particle: :remove })
+new({ particle: :remove, category: :property, type: :hash }) 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({ post: :remove }) do |params|
   # TODO : we have to rethink the removal of atome and particles (with exception like category) and maybe 'use particle type' to handle removal
@@ -40,17 +53,17 @@ new({ post: :remove }) do |params|
   params
 end
 
-new({ particle: :classes }) do |value|
+new({ particle: :classes, category: :material, type: :json }) do |value|
   Universe.classes[value] ||= []
   Universe.classes[value] |= [id]
 end
-new({ particle: :remove_classes }) do |value|
+new({ particle: :remove_classes, category: :material, type: :boolean }) do |value|
   Universe.classes[value].delete(id)
 end
-new ({ particle: :opacity })
+new ({ particle: :opacity, category: :material, type: :int })
 
 # vector shape
-new({ particle: :definition })
+new({ particle: :definition, category: :material, type: :string })
 
 new({ sanitizer: :definition }) do |params|
   # we remove the unwanted svg tags
@@ -58,5 +71,5 @@ new({ sanitizer: :definition }) do |params|
   params
 end
 
-new({ particle: :gradient })
-new({ particle: :border })
+new({ particle: :gradient, category: :material, type: :int })
+new({ particle: :border, category: :material, type: :int })