atome 0.5.6.1.1 → 0.5.6.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b95189cdeb5fd525c61044cb540b3ff487ab48afdaaf162cc8330d5dc01edd5b
-  data.tar.gz: a7b2cc31314513f94123cf12f9223eb892fd3275c4f0e73d4921775ba1f58e0e
+  metadata.gz: c9f271978fff8b31e480fd6d7dd63b4714f22f658c602a2725234bdb747e29bc
+  data.tar.gz: 7d61a71ff963c9b68b15dbbbe0a6469865d1aa82e958dca9b5cfffc4ad5ffd8c
 SHA512:
-  metadata.gz: ff8cf89846a9b8abf0210356b2fd3b80a084e92bb309ee0ec263ca154d559ac84c8499da7e9161f91785ad46babb45a9c7d2d68f990b2f5a3cc7ca52cf24c0da
-  data.tar.gz: 98e1d3e237e35adba9c1319b814c0c3c7b04620e513cf9ece38770f21f683b93c3235ff88822bd84c6b3d76c118ed8b6a864067da4afc73686476ea907644334
+  metadata.gz: c9b78286af7e45b82ab00792ab2a4a11ec008c2fee10cd110666cd38a9ae11c1b5d8e6bc520854f3e033018a05046fb4d92296da7360522d4d9ef4a1ec0de1ea
+  data.tar.gz: 365f481ee7933540065b259b4ea5d3b55515dc0b2b96f0dfc57231c55c927b54e307a41a551b208c8825e81dfe535b9be006b2dd05330ecfa78be32678d31c02

data/Rakefile

@@ -161,7 +161,7 @@ task :test_opal do
 
   puts 'atome opal is build and running!'
 end
-task :server_wasm do
+task :test_server_wasm do
   project_name = :test
   source = '.'
   destination = './tmp'
@@ -171,7 +171,7 @@ task :server_wasm do
   create_application(source, destination, project_name)
   wasm_common(source, destination, project_name, wasi_file, host_mode, script_source)
   puts 'atome wasm is build and running!'
-  build_for_server(destination, project_name, 9292, :production)
+  build_for_wasm_server(destination, project_name, 9292, :production)
 
 end
 task :test_server do
@@ -213,7 +213,51 @@ task :test_server do
     end
 
   end
-  build_for_server(destination, project_name, 9292, :production)
+  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
@@ -292,7 +336,7 @@ task :osx_server do
   destination = './tmp'
   threads = []
   threads << Thread.new do
-    build_for_server(destination, project_name, 9292, :production)
+    build_for_opal_server(destination, project_name, 9292, :production)
   end
   build_for_osx(destination)
 

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

@@ -353,7 +353,7 @@ def build_for_osx(destination, mode = :dev)
 
 end
 
-def build_for_server(destination, project_name, port, production)
+def build_for_opal_server(destination, project_name, port, production)
   if production
     prod = '--env production'
     ru_file = <<STR
@@ -394,6 +394,55 @@ STR
 
 end
 
+
+def build_for_wasm_server(destination, project_name, port, production)
+  if production
+    prod = '--env production'
+    ru_file = <<STR
+require 'roda'
+require './atome_server_wasm.rb'
+run App.app.freeze
+STR
+  else
+    ru_file = <<STR
+require 'roda'
+require 'rack/unreloader'
+Unreloader = Rack::Unreloader.new(subclasses: %w[Roda]) { App }
+Unreloader.require './atome_server_wasm.rb'
+run Unreloader
+require './atome_server.rb'
+STR
+  end
+
+  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+
+    # code to exec with Windows
+    File.open("#{destination}\\#{project_name}\\server\\config.ru", "w") do |f|
+      f.write(ru_file)
+    end
+    `cd /d #{destination}\\#{project_name}\\server && puma --port #{port} #{prod}`
+  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
+    # code to exec with MacOS
+    File.open("#{destination}/#{project_name}/server/config.ru", "w") do |f|
+      f.write(ru_file)
+    end
+    puts 'w-a'
+
+    `cd #{destination}/#{project_name}/server;puma --port #{port} #{prod}`
+    puts 'w-b'
+
+  else
+    puts 'e'
+    # code to exec with Unix/Linux
+    File.open("#{destination}/#{project_name}/server/config.ru", "w") do |f|
+      f.write(ru_file)
+    end
+    `cd #{destination}/#{project_name}/server;puma --port #{port} #{prod}`
+  end
+  puts 'f'
+
+end
+
 # utils
 def ensure_rb_extension(filename)
   filename.end_with?('.rb') ? filename : "#{filename}.rb"
@@ -703,13 +752,38 @@ else
       # end
     end
     threads << Thread.new do
-      build_for_server(destination, project_name, 9292, false)
+      build_for_opal_server(destination, project_name, 9292, false)
     end
 
     threads.each(&:join)
 
   end
 
+  if ARGV.include?('wasm_server')
+    puts 'building Server'
+    build_opal_application(nil, destination, project_name)
+    build_host_mode(destination, project_name, 'web-opal')
+    threads = []
+    # threads << Thread.new do
+    #   # sleep 1
+    #   # if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+    #   #   # code to exec with Windows
+    #   #   `start "" "#{destination}\\#{project_name}\\src\\index_server.html`
+    #   # elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
+    #   #   # code to exec with MacOS
+    #   #   `open http://localhost:9292`
+    #   # else
+    #   #   # code to exec with Unix/Linux
+    #   #   `open http://localhost:9292`
+    #   # end
+    # end
+    threads << Thread.new do
+      build_for_wasm_server(destination, project_name, 9292, false)
+    end
+    threads.each(&:join)
+    puts 'wasm server is running'
+  end
+
   if ARGV.include?('server_refresh')
     puts 're building Server'
     build_opal_application(nil, destination, project_name)

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,31 +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)
 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