atome 0.5.7.3.9 → 0.5.7.4.2

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

@@ -21,14 +21,6 @@ new({ particle: :remove, category: :property, type: :hash }) do |params|
       data.map do |hash|
         hash.delete(hash.keys[column]) if hash.keys[column]
       end
-      # elsif params[:all]
-      #   apply.each do |applied_atome|
-      #     if  grab(applied_atome).type.to_sym ==  params[:all].to_sym
-      #       puts "!go"
-      #     end
-      #   end
-      # puts "so_good #{params}"
-      # puts "***> #{apply}"
     end
 
     params
@@ -38,7 +30,6 @@ new({ particle: :remove, category: :property, type: :hash }) do |params|
   end
 
 end
-# new({ particle: :remove, category: :property, type: :hash })
 
 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
@@ -86,7 +77,6 @@ end
 new({ particle: :remove_classes, category: :material, type: :boolean }) do |value|
   Universe.classes[value].delete(id)
 end
-# new ({ particle: :opacity, category: :material, type: :int })
 
 # vector shape
 new({ particle: :definition, category: :material, type: :string })
@@ -115,7 +105,6 @@ new({ after: :pattern }) do |params|
   end
   params
 end
-# new({ particle: :border, category: :material, type: :int })
 new({ particle: :fill, category: :material, type: :array })
 
 new({ particle: :opacity, category: :material, type: :int })

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

@@ -11,29 +11,27 @@ def extract_rgb_alpha(color_string)
 end
 
 new({ particle: :red, category: :property, type: :string }) do
-  # alert :ok
   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
   self
 end
 # FIXME  we have to apply both at post and after to make it work
 # used to refresh all affected atomes
-new({after: :red}) do |params|
-  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
+new({ after: :red }) do |params|
+  a = affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
   a.each do |atome_to_refresh|
-      grab(atome_to_refresh).apply(id)
-    end
+    grab(atome_to_refresh).apply(id)
+  end
   params
 end
 
-
 new({ particle: :green, category: :property, type: :string }) do
   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
   self
 end
 
 # used to refresh all affected atomes
-new({after: :green}) do |params|
-  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
+new({ after: :green }) do |params|
+  a = affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
   a.each do |atome_to_refresh|
     grab(atome_to_refresh).apply(id)
   end
@@ -46,8 +44,8 @@ new({ particle: :blue, category: :property, type: :string }) do
 end
 
 # used to refresh all affected atomes
-new({after: :blue}) do |params|
-  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
+new({ after: :blue }) do |params|
+  a = affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
   a.each do |atome_to_refresh|
     grab(atome_to_refresh).apply(id)
   end
@@ -58,8 +56,8 @@ new({ particle: :alpha, category: :property, type: :string }) do
   self
 end
 # used to refresh all affected atomes
-new({after: :alpha}) do |params|
-  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
+new({ after: :alpha }) do |params|
+  a = affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
   a.each do |atome_to_refresh|
     grab(atome_to_refresh).apply(id)
   end
@@ -70,7 +68,6 @@ new({ particle: :diffusion, category: :property, type: :string }) do
   self
 end
 
-
 new({ particle: :clean, category: :property, type: :boolean }) do |params|
   cell = params[:cell]
   row_nb = cell[0]
@@ -91,6 +88,7 @@ new({ particle: :insert, category: :property, type: :string }) do |params|
     position_to_insert = params[:row]
     data.insert(position_to_insert, {})
   elsif params[:column]
+    #
   end
 
   params
@@ -130,7 +128,7 @@ new({ particle: :sort, category: :property, type: :int }) do |params|
   params
 end
 
-new({particle: :inside, render: false})
+new({ particle: :inside, render: false })
 new({ initialized: :inside }) do |params, &user_proc|
   render(:inside, params, &user_proc)
 end
@@ -142,11 +140,11 @@ new({ particle: :value }) do |val|
   val
 end
 
-new({ particle: :behavior, type: :symbol, category: :property  })
+new({ particle: :behavior, type: :symbol, category: :property })
 
 new({ particle: :orientation, type: :symbol, category: :property })
 
-new({ particle: :align , type: :symbol, category: :property })
+new({ particle: :align, type: :symbol, category: :property })
 
 new({ particle: :actor, store: false }) do |params|
   @actor ||= {}

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

@@ -27,51 +27,6 @@ end
 
 new({ read: :password }) do |params|
   # TODO : check if we have to reactive the lines below
-  # params = Black_matter.password if params.nil?
-  # params[:read][:atome] = Black_matter.password[:read][:atome] unless @authorisations[:write][:atome]
-  # params[:write][:atome] = Black_matter.password[:write][:atome] unless @authorisations[:write][:atome]
 
   params
 end
-
-# def get_all_local_storage_items
-  # Création d'un hash pour stocker les paires clé/valeur de localStorage
-  storage_items = {}
-
-  # Obtention du nombre d'éléments dans le localStorage
-#   storage= JS.global[:localStorage]
-# # storage=storage.to_s
-# storage_array= storage.to_a
-# # alert storage_array.length
-# storage_items={}
-# storage_array.each_with_index do |_i, index|
-#   key = JS.global[:localStorage].key(index)
-#   #
-#   #     # Récupération de la valeur associée à cette clé
-#       value = JS.global[:localStorage].getItem(key)
-#   #
-#   #     # Stockage de la paire clé/valeur dans le hash
-#       storage_items[key] = value
-# end
-# puts storage_items
-
-  # alert Native(storage_length).class
-  # Itération sur tous les éléments de localStorage
-#   (0...storage_length).each do |i|
-#     # Récupération de la clé pour l'élément actuel
-#     key = JS.global[:localStorage].key(i)
-#
-#     # Récupération de la valeur associée à cette clé
-#     value = JS.global[:localStorage].getItem(key)
-#
-#     # Stockage de la paire clé/valeur dans le hash
-#     storage_items[key] = value
-#   end
-#
-#   # Retour du hash contenant toutes les paires clé/valeur de localStorage
-#   storage_items
-# end
-#
-# # Appel de la fonction pour récupérer et afficher le contenu de localStorage
-# all_items = get_all_local_storage_items
-# puts all_items

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

@@ -1,20 +1,29 @@
 # frozen_string_literal: true
+def delete_recursive(atome_id, force=false)
+  return if grab(atome_id).tag && (grab(atome_id).tag[:persistent] || grab(atome_id).tag[:system]) unless force
+
+  parent_id_found = grab(atome_id).attach
+  parent_found = grab(parent_id_found)
+  new_array = parent_found.fasten.dup
+  new_array.delete(atome_id)
+  parent_found.instance_variable_set('@fasten', new_array)
+  grab(atome_id).fasten.each do |atome_id_found|
+    delete_recursive(atome_id_found, force)
+  end
+  grab(atome_id).render(:delete, { :recursive => true })
+  grab(atome_id).touch(:remove)
+  Universe.delete(grab(atome_id).aid)
+end
 
 new({ particle: :renderers, category: :utility, type: :string })
 new({ particle: :code, category: :utility, type: :string, store: false }) do |params, code|
   @code[params] = code
 end
-# new({ particle: :run, category: :utility, type: :boolean }) do |params|
-#   code_found = @code
-#   instance_exec(params, &code_found) if code_found.is_a?(Proc)
-# end
-
 new({ particle: :run }) do |params, code|
   instance_exec(&params) if params.is_a?(Proc)
   code_found = @code[params]
   instance_exec(params, &code_found) if code_found.is_a?(Proc)
 end
-
 new({ particle: :target }) do |params|
   params.each do |atome_f, value_f|
     if value_f.instance_of?(Hash)
@@ -26,26 +35,6 @@ new({ particle: :target }) do |params|
     end
   end
 end
-
-# new({ particle: :broadcast })
-
-
-def delete_recursive(atome_id, force=false)
-  return if grab(atome_id).tag && (grab(atome_id).tag[:persistent] || grab(atome_id).tag[:system]) unless force
-
-  parent_id_found = grab(atome_id).attach
-  parent_found = grab(parent_id_found)
-  new_array = parent_found.fasten.dup
-  new_array.delete(atome_id)
-  parent_found.instance_variable_set('@fasten', new_array)
-  grab(atome_id).fasten.each do |atome_id_found|
-    delete_recursive(atome_id_found, force)
-  end
-  grab(atome_id).render(:delete, { :recursive => true })
-  grab(atome_id).touch(:remove)
-  Universe.delete(grab(atome_id).aid)
-end
-
 new({ particle: :delete, category: :utility, type: :boolean, render: false }) do |params|
   if params == true
 
@@ -68,31 +57,15 @@ new({ particle: :delete, category: :utility, type: :boolean, render: false }) do
         affected_found.apply.delete(id_found)
         affected_found.refresh
       end
+      grab(attach).unfasten([id])
       Universe.delete(@aid)
     end
-    # elsif params == :force
-    #   cells.delete(true)
-    #   group.delete(true)
-    #   # now we detach the atome from it's parent
-    #   # now we init rendering
-    #   render(:delete, params)
-    #   # the machine delete the current atome from the universe
-    #   id_found = @id.to_sym
-    #   if @attach
-    #     parent_found = grab(@attach)
-    #     parent_found.fasten.delete(id_found)
-    #   end
-    #   @affect&.each do |affected_atome|
-    #     affected_found = grab(affected_atome)
-    #     affected_found.apply.delete(id_found)
-    #     affected_found.refresh
-    #   end
-    #   Universe.delete(@aid)
   elsif params.instance_of? Hash
     # if we are on a matrix we delete cells found & group found
     cells.delete(true)
     group.delete(true)
     if params[:recursive]
+      grab(attach).unfasten([id])
       unless grab(@id).tag && (grab(@id).tag[:persistent] || grab(@id).tag[:system])
         fasten.each do |atttached_atomes|
           delete_recursive(atttached_atomes)
@@ -128,119 +101,7 @@ new({ particle: :delete, category: :utility, type: :boolean, render: false }) do
     send(params, 0) unless params == :id
   end
 end
-
-
-# def delete_recursive(atome_id, force = false)
-#   return if grab(atome_id).tag && (grab(atome_id).tag[:persistent] || grab(atome_id).tag[:system]) unless force
-#
-#   parent_id_found = grab(atome_id).attach
-#   parent_found = grab(parent_id_found)
-#   new_array = parent_found.fasten.dup
-#   new_array.delete(atome_id)
-#   parent_found.instance_variable_set('@fasten', new_array)
-#   grab(atome_id).fasten.each do |atome_id_found|
-#     delete_recursive(atome_id_found, force)
-#   end
-#   grab(atome_id).render(:delete, { :recursive => true })
-#   grab(atome_id).touch(:remove)
-#   Universe.delete(grab(atome_id).aid)
-# end
-
-# new({ particle: :delete, category: :utility, type: :boolean, render: false }) do |params|
-#
-#   basic_system_object = %i[view eDen black_matter intuition copy atome
-#   user_view view_color shape_color
-# box_color invisible_color text_color circle_color back_selection
-# text_selection nil
-# ]
-#
-#   unless basic_system_object.include?(id) || id.nil?
-#    if params == true
-#       # We use the tag persistent to exclude color of system object and other default colors
-#       unless @tag && (@tag[:persistent] || @tag[:system])
-#         # if we are on a matrix we delete cells found & group found
-#         cells.delete(true)
-#         group.delete(true)
-#         # now we detach the atome from it's parent
-#         # now we init rendering
-#         render(:delete, params)
-#         # the machine delete the current atome from the universe
-#         id_found = @id.to_sym
-#         if @attach
-#           parent_found = grab(@attach)
-#           parent_found.fasten.delete(id_found)
-#         end
-#         @affect&.each do |affected_atome|
-#           affected_found = grab(affected_atome)
-#           affected_found.apply.delete(id_found)
-#           affected_found.refresh
-#         end
-#         # Universe.delete(@aid)
-#       end
-#     elsif params.instance_of? Hash
-#       # if we are on a matrix we delete cells found & group found
-#       cells.delete(true)
-#       group.delete(true)
-#       if params[:recursive]
-#         unless grab(@id).tag && (grab(@id).tag[:persistent] || grab(@id).tag[:system])
-#           fasten.each do |atttached_atomes|
-#             delete_recursive(atttached_atomes)
-#           end
-#           # touch(:remove)
-#           # render(:delete, params)
-#           # Universe.delete(@aid)
-#         end
-#       elsif params[:force]
-#         fasten.each do |atttached_atomes|
-#           # alert "fasten : #{fasten}"
-#           delete_recursive(atttached_atomes, true)
-#         end
-#         # touch(:remove)
-#         # render(:delete, params)
-#         # Universe.delete(@aid)
-#
-#       else
-#
-#         # the machine try to find the sub particle id and remove it eg a.delete(monitor: :my_monitor) remove the monitor
-#         # with id my_monitor
-#         #
-#         params.each do |param, value|
-#           atome[param][value] = nil
-#         end
-#       end
-#
-#     elsif Universe.atome_list.include?(params)
-#       # we check if the params passed is an atome to treat it in a different way
-#       puts "write code here : #{apply} , #{fasten}"
-#     else
-#       send(params, 0) unless params == :id
-#     end
-#     touch(:remove)
-#     drag(false)
-#     drop(false)
-#     on(false)
-#     keyboard(false)
-#     resize(:remove)
-#     overflow(:remove)
-#
-#     render(:delete, params)
-#     Universe.delete(@aid)
-#
-#     exclusions = %i[@history @renderers @type @tag @html]
-#
-#     instance_variables.each do |i_var|
-#       unless exclusions.include?(i_var)
-#         instance_variable_set(i_var, nil)
-#       end
-#     end
-#
-#     instance_variable_set('@renderers', [])
-#   end
-#
-# end
-
 new({ particle: :clear, category: :utility, type: :boolean })
-
 new({ post: :clear }) do
   fasten_found = []
   fasten.each do |fasten_id_found|
@@ -261,9 +122,7 @@ new({ particle: :schedule, category: :utility, type: :string }) do |date, proc|
     send("#{renderer}_schedule", format_date, &proc)
   end
 end
-
 new({ particle: :cursor, category: :utility, type: :string })
-
 new({ particle: :preset, category: :utility, type: :string }) do |params|
 
   if params.instance_of? Hash
@@ -284,7 +143,6 @@ end
 new({ particle: :relations, category: :utility, type: :hash })
 new({ particle: :tag, render: false, category: :utility, type: :hash })
 new({ particle: :web, category: :utility, type: :string })
-# new({ particle: :metrics, type: :hash })
 # do not change the line below initialise is a special method
 new({ initialize: :unit, value: {} })
 new({ particle: :unit, store: false, type: :string, category: :utility }) do |params|
@@ -306,19 +164,15 @@ new({ particle: :browse, category: :utility, type: :string })
 new({ particle: :copies, category: :utility, type: :string })
 new({ particle: :temporary, category: :utility, type: :int })
 new({ particle: :atomes, category: :utility, type: :string })
-
 new({ particle: :match, category: :utility, type: :string }) do |params, _bloc|
   params
 end
-
 new({ sanitizer: :match }) do |params, _bloc|
   params[:condition] = { min: { width: 0 } } unless params[:condition]
   params
 end
-
 new({ particle: :invert, category: :utility, type: :boolean })
 new({ particle: :option, category: :utility, type: :string })
-
 new({ particle: :duplicate, category: :utility, type: :string, store: false }) do |params|
   copy_number = if @duplicate
                   @duplicate.length
@@ -347,16 +201,13 @@ new({ particle: :duplicate, category: :utility, type: :string, store: false }) d
   new_atome
 
 end
-
 new({ after: :duplicate }) do |params|
   @duplicate[@duplicate.keys[@duplicate.keys.length - 1]]
 end
-
 new({ particle: :copy, category: :utility, type: :string }) do |items_id|
   items_id = [items_id] unless items_id.instance_of? Array
   grab(:copy).collect << items_id
 end
-
 new({ particle: :paste, category: :utility, type: :string }) do |params|
 
   all_copies = grab(:copy).collect
@@ -382,37 +233,28 @@ new({ particle: :paste, category: :utility, type: :string }) do |params|
   end
   new_atomes
 end
-
 new({ read: :paste }) do |p|
   @copy
 end
-
 new({ particle: :backup, category: :utility, type: :string })
-
 new({ particle: :import, category: :utility, type: :string })
-
 new({ particle: :compute, category: :utility, type: :string }) do |params|
   params = { particle: params } unless params.instance_of?(Hash)
   params[:unit] ||= :pixel
   params[:reference] ||= :view
   params
 end
-
 new({ particle: :get, category: :utility, type: :string }) do |params|
   cell = params[:cell]
   row_nb = cell[0]
   column_nb = cell[1]
   data[row_nb][data[row_nb].keys[column_nb]] # we get the content of the cell
 end
-
 new({ particle: :css, category: :utility, type: :string })
-
 new({ read: :css }) do
   CssProxy.new(js, nil, self)
 end
-
 new({ particle: :holder, category: :utility, type: :atome })
-
 # this particle is mainly used in conjunction with alternate particle as a 'lambda' to alternate  methods
 new({ particle: :executor, category: :utility, type: :hash }) do |params|
   params.each do |method, opt|
@@ -420,22 +262,12 @@ new({ particle: :executor, category: :utility, type: :hash }) do |params|
   end
   params
 end
-
 new({ particle: :tick, category: :utility, store: false, type: :hash }) do |val|
   @tick[val] ||= 0
   @tick[val] = @tick[val] += 1
   @tick[val]
 end
-
 new({ particle: :storage, category: :utility, type: :hash })
 new({ particle: :state, category: :utility, type: :symbol })
-
 new({ particle: :record, category: :utility, type: :hash })
 new({ particle: :preview, category: :utility, type: :hash })
-
-# new(particle: :update) do |params| # specific to buttons molecule for now
-#   old_data= data
-#   delete({recursive: true})
-#   new_content=old_data.merge(params)
-#   buttons(new_content)
-# end

data/lib/atome/genesis/sparkle.rb

@@ -92,7 +92,6 @@ Atome.new({ renderers: default_render, id: machine_id, type: :machine, password:
 # user
 user_password = { global: :star_win, read: { atome: :star_wars }, write: { atome: :star_wars } }
 
-# human({ id: :anonymous, login: true, password: user_password, data: { birthday: '10/05/1996' }, selection: [], attach: :user_view })
 human({ id: identity_generator, login: true, password: user_password, data: { birthday: '10/05/1996' }, selection: [], attach: :user_view })
 
 Universe.current_machine = machine_id
@@ -161,14 +160,8 @@ def init_database
   A.sync({ action: :init_db, data: { database: :eDen } }) do |data|
     Universe.database_ready = data[:data][:message] == 'database_ready'
   end
-  # authentication : email, pass
-  # atome : date, particles
-  # history : aid, particle, value, date
-
-  particles = Universe.particle_list
   # now we populate the DB
   A.sync({ action: :create_db_table, data: { table: :user, type: :string } }) do |_db_state|
-    # puts "===> #{_db_state}"
   end
   A.sync({ action: :create_db_table, data: { table: :atome } }) do |_db_state|
   end
@@ -191,13 +184,11 @@ def init_database
 
 
   # now we send localstorage content to the server
-  # puts "sending localstorage"
   Atome.send_localstorage_content
 
 end
 
 def user_login
-  # user = Universe.current_user
   password = Black_matter.password
   sync({ action: :authentication, data: { email: 'jeezs@atome.one' } }) do |email|
     puts "email received : #{email}"
@@ -212,6 +203,6 @@ end
 # Universe.allow_sync= false # to stop data to be sync on server
 touch_allow(false) # this lock the system right click in web view
 # add a few default font
-# A.add_text_visual({ path: 'Roboto', name: 'Roboto-Bold' })
-# A.add_text_visual({ path: 'Roboto', name: 'Roboto-Thin' })
-# A.add_text_visual({ path: 'Roboto', name: 'Roboto-LightItalic' })
+A.add_text_visual({ path: 'Roboto', name: 'Roboto-Bold' })
+A.add_text_visual({ path: 'Roboto', name: 'Roboto-Thin' })
+A.add_text_visual({ path: 'Roboto', name: 'Roboto-LightItalic' })

data/lib/atome/kernel/black_matter.rb

@@ -6,7 +6,6 @@ class Black_matter
       JS.global.sha256(string.to_s)
     end
 
-
     def check_password(input_password, stored_hash)
       input_hash = encode(input_password)
       input_hash == stored_hash

data/lib/atome/kernel/universe.rb

@@ -23,32 +23,24 @@ class Universe
   @allow_sync = false # temp server storage sync
   @connected = false
   @database_ready = false
-  @tools_root=[]
+  @tools_root = []
   @tools = {}
   @allow_tool_operations = false
   @active_tools = []
   @atome_preset = []
-  @default_selection_style={border: { thickness: 1, red: 1, green: 0, blue: 0, alpha: 1, pattern: :dotted }}
-  @applicable_atomes= %i[color shadow border paint animation]
+  @default_selection_style = { border: { thickness: 1, red: 1, green: 0, blue: 0, alpha: 1, pattern: :dotted } }
+  @applicable_atomes = %i[color shadow border paint animation]
   # @historicize=false
   class << self
     attr_reader :atomes, :atomes_ids, :renderer_list, :molecule_list, :atome_list, :particle_list, :classes, :counter,
                 :atomes_specificities
-    attr_accessor :connected, :allow_sync, :allow_localstorage, :database_ready, :edit_mode, :tools,:tools_root,
+    attr_accessor :connected, :allow_sync, :allow_localstorage, :database_ready, :edit_mode, :tools, :tools_root,
                   :allow_tool_operations, :active_tools, :atome_preset, :applicable_atomes, :default_selection_style
 
     def messages
       @messages
     end
 
-    # def eVe(val = nil)
-    #   if val
-    #     @eve = val
-    #   else
-    #     @eve
-    #   end
-    # end
-
     def store_messages(new_msg)
       @messages[new_msg[:msg_nb]] = new_msg[:proc]
     end
@@ -98,13 +90,11 @@ class Universe
 
     def add_sanitizer_method(method_name, &method_proc)
       # this method is used to add sanitizer methods
-      # instance_variable_get('@sanitizers').merge!({ method_name => method_proc })
       @sanitizers.merge!({ method_name => method_proc })
     end
 
     def get_sanitizer_method(method_name)
       # this method is used to add optional methods
-      # instance_variable_get('@sanitizers')[method_name]
       @sanitizers[method_name]
     end
 
@@ -125,21 +115,10 @@ class Universe
       @atomes_ids[id] = aid
     end
 
-    # def update_atome_id(aid, atome, prev_id)
-    #   @atomes[id] = atome
-    #   @atomes.delete(prev_id)
-    # end
-    # def update_atome_id(id, atome, prev_id)
-    #   @atomes[id] = atome
-    #   @atomes.delete(prev_id)
-    # end
-
     def user_atomes
       collected_id = []
-      @atomes.each do |id_found, atome_found|
-        # collected_id << id_found unless atome_found.tag && atome_found.tag[:system]
+      @atomes.each_value do |atome_found|
         collected_id << atome_found.id unless atome_found.tag && atome_found.tag[:system]
-
       end
       collected_id
     end
@@ -217,7 +196,6 @@ class Universe
     end
 
     def current_server
-      # return unless RUBY_ENGINE.downcase == 'opal'
       JS.global[:location][:href].to_s
     end
 
@@ -275,34 +253,16 @@ class Universe
         operation_timing = Time.now.strftime("%Y%m%d%H%M%S%3N") + @increment.to_s
         @increment += 1
         @increment = @increment % 100
-        # puts "===> { #{id} => { #{operation} => { #{element} => #{params} } }, sync: false }"
-        # puts "<==== #{@allow_localstorage} : #{element} ====>"
         if @allow_localstorage.include? element
           JS.global[:localStorage].setItem(operation_timing, "{ #{id} => { #{operation} => { #{element} => #{params} } }, sync: false }")
           @history[@history.length] = { operation_timing => { id => { operation => { element => params } }, sync: false, time: Time.now } }
-          # puts "===> { #{id} => { #{operation} => { #{element} => #{params} } }, sync: false }"
         end
 
-
       end
     end
 
     def story
       @history
-      # # temp algo awaiting db to be ready, just for POC and tests
-      # return unless filter
-      #
-      # operation = filter[:operation]
-      # atome_id = filter[:id]
-      # particle = filter[:particle]
-      # filtered_history = []
-      # @history.each do |operation_number, alteration|
-      #   if alteration[atome_id] && (alteration[atome_id][operation]) && (alteration[atome_id][operation][particle])
-      #     filtered_history << { operation: operation_number, filter[:particle] => alteration[atome_id][operation][particle], sync: alteration[:sync], time: alteration[:time] }
-      #   end
-      # end
-      # filtered_history
     end
-
   end
 end