atome 0.5.7.0.3 → 0.3191

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

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-def extract_rgb_alpha(color_string)
-  match_data = color_string.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*(\d+(?:\.\d+)?))?\)/)
-  red = match_data[1].to_i
-  green = match_data[2].to_i
-  blue = match_data[3].to_i
-  alpha = match_data[4] ? match_data[4].to_f : nil
-  { red: red, green: green, blue: blue, alpha: alpha }
-
-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
-  a.each do |atome_to_refresh|
-      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
-  a.each do |atome_to_refresh|
-    grab(atome_to_refresh).apply(id)
-  end
-  params
-end
-
-new({ particle: :blue, 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: :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
-  params
-end
-new({ particle: :alpha, 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: :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
-  params
-end
-new({ particle: :diffusion, category: :property, type: :string }) do
-  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-  self
-end
-
-
-new({ particle: :clean, category: :property, type: :boolean }) do |params|
-  cell = params[:cell]
-  row_nb = cell[0]
-  column_nb = cell[1]
-  data[row_nb][data[row_nb].keys[column_nb]] = "" # we remove the data from the cell
-  params
-end
-
-new({ particle: :insert, category: :property, type: :string }) do |params|
-  # cell
-  if params[:cell]
-    content = params[:content]
-    cell = params[:cell]
-    row_nb = cell[0]
-    column_nb = cell[1]
-    data[row_nb][data[row_nb].keys[column_nb]] = content # we remove the data from the cell
-  elsif params[:row]
-    position_to_insert = params[:row]
-    data.insert(position_to_insert, {})
-  elsif params[:column]
-  end
-
-  params
-end
-
-new({ particle: :sort, category: :property, type: :int }) do |params|
-  column = params[:column]
-  method = params[:method]
-
-  if column.nil? || method.nil?
-    puts "Column and method parameters are required."
-    return
-  end
-
-  @data.sort_by! do |row|
-    value = row.values[column - 1]
-    if value.instance_of? Atome
-      0
-    else
-      case method
-      when :alphabetic
-        value.to_s
-      when :numeric
-        if value.is_a?(Numeric)
-          value
-        elsif value.respond_to?(:to_i)
-          value.to_i
-        else
-          0
-        end
-      else
-        value
-      end
-    end
-  end
-
-  params
-end
-
-new({particle: :inside, render: false})
-new({ initialized: :inside }) do |params, &user_proc|
-  render(:inside, params, &user_proc)
-end
-new({ particle: :margin })
-
-new({ particle: :value }) do |val|
-  pro_f = behavior[:value]
-  instance_exec(val, &pro_f) if pro_f.is_a?(Proc)
-  val
-end
-
-new({ particle: :behavior })
-
-new({ particle: :orientation, type: :symbol, category: :property })

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

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-new ({ particle: :password, category: :security, type: :string })
-new ({ sanitizer: :password }) do |params|
-
-  params = { read: params, write: params } unless params.instance_of? Hash
-
-  # encoding below
-  params[:global] = Black_matter.encode(params[:global])
-
-  params[:read]&.each do |k, v|
-    params[:read][k] = Black_matter.encode(v)
-  end
-  params[:write]&.each do |k, v|
-    params[:write][k] = Black_matter.encode(v)
-  end
-
-  params[:read] = Black_matter.password unless params[:read]
-  params[:write] = Black_matter.password unless params[:write]
-
-  if type == :human
-    # we store the hashed password into the Universe for easier access
-    Black_matter.set_password(params)
-  end
-  params
-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/spatial.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-new({ particle: :left, category: :spatial, type: :int })
-new({ particle: :right, category: :spatial, type: :int })
-new({ particle: :top, category: :spatial, type: :int })
-new({ particle: :bottom, category: :spatial, type: :int })
-new({ particle: :rotate, category: :spacial, type: :integer })
-new({ particle: :direction, category: :spatial, type: :string })
-new({ particle: :depth, category: :spatial, type: :integer })
-new({ particle: :position, category: :spatial, type: :int })
-new({ particle: :organise, category: :spatial, type: :string })
-new({ particle: :spacing, category: :spatial, type: :string })
-new({ particle: :display, category: :spatial, type: :boolean }) do |params|
-  params = { mode: params } unless params.instance_of? Hash
-  params
-end
-new({ particle: :layout, category: :spatial, type: :int }) do |params|
-  mode_found = params.delete(:mode) || :list
-  elements_style = params.delete(:element) || {}
-  # now we get the list of the atome to layout
-  atomes_to_organise = []
-  atomes_to_organise = collect if type == :group
-  # if params[:listing] is specified group collection is override
-  atomes_to_organise = params[:listing] if params[:listing]
-  if mode_found == :default
-    # the user want to revert the layout to the default
-    atomes_to_organise.each do |atome_id_to_organise|
-      atome_found = grab(atome_id_to_organise)
-      # now restoring
-      next unless atome_found.backup
-
-      atome_found.backup.each do |particle, value|
-        atome_found.send(:delete, particle)
-        atome_found.send(particle, value)
-      end
-      atome_found.remove_layout
-    end
-  else
-
-    if params[:id]
-      container_name = params[:id]
-      container = grab(:view).box({ id: container_name })
-      container_class = container_name
-    else
-      container = grab(:view).box
-      id_found = container.id
-      params[:id] = id_found
-      container_class = id_found
-    end
-    container.remove({ category: :atome })
-    container.category(:matrix)
-    params[:organise] = '1fr' if mode_found == :list
-    params.each do |particle, value|
-      container.send(particle, value)
-    end
-    # now we add user wanted particles
-    atomes_to_organise.each do |atome_id_to_organise|
-      atome_found = grab(atome_id_to_organise)
-      # now restoring
-      # atome_found.remove_layout
-      atome_found.backup&.each do |particle, value|
-        atome_found.send(:delete, particle)
-        atome_found.send(particle, value)
-      end
-      # we remove previous display mode
-      atome_found.remove_layout
-      atome_found.display[:mode] = mode_found
-      atome_found.display[:layout] = id_found
-      atome_found.attach(container_class)
-      atome_found.remove({ category: :atome })
-      atome_found.category(container_class)
-      # the hash below is used to restore element state
-
-      # we only store the state if  atome_found.display[:default]== {} it means this is the original state
-      elements_style.each do |particle, value|
-        # we have to store all elements particle to restore it later
-        atome_found.backup({}) unless atome_found.backup
-        unless atome_found.backup[particle]
-          particle_to_save = atome_found.send(particle) || 0
-          atome_found.backup[particle] = particle_to_save
-        end
-
-        atome_found.send(particle, value)
-      end
-    end
-  end
-  params
-end
-new({ particle: :center, category: :spatial, type: :hash }) do |params|
-  params = { x: 0, y: 0, dynamic: true } if params == true
-  params
-end
-new ({ particle: :increment, category: :spatial, type: :hash }) do |params|
-  params.each do |particle, value|
-    prev_value=send(particle)
-    send(particle, value+prev_value)
-  end
-end

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

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-# create particles
-new({ particle: :markers, category: :time, type: :hash })

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

@@ -1,261 +0,0 @@
-# frozen_string_literal: true
-
-new({ particle: :renderers, category: :utility, type: :string })
-new({ particle: :code, category: :utility, type: :string })
-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: :broadcast })
-
-def delete_recursive(atome_id)
-  return if grab(atome_id).tag && (grab(atome_id).tag[:persistent] || grab(atome_id).tag[:system])
-
-  parent_id_found = grab(atome_id).attach
-  parent_found = grab(parent_id_found)
-  new_array = parent_found.attached.dup
-  new_array.delete(atome_id)
-  parent_found.instance_variable_set('@attached', new_array)
-  grab(atome_id).attached.each do |atome_id_found|
-    delete_recursive(atome_id_found)
-  end
-  grab(atome_id).render(:delete, { :recursive => true })
-  grab(atome_id).touch(:remove)
-  Universe.delete(atome_id)
-end
-
-new({ particle: :delete, category: :utility, type: :boolean, render: false }) do |params|
-  if params == true
-    # We use the tag persistent to exclude color of system object and other default colors
-    unless @tag && (@tag[:persistent] || @tag[:system])
-      # 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
-      parent_found = grab(@attach)
-      parent_found.attached.delete(id_found)
-      Universe.delete(@aid)
-    end
-  elsif params.instance_of? Hash
-
-    if params[:recursive]
-      unless grab(@id).tag && (grab(@id).tag[:persistent] || grab(@id).tag[:system])
-        attached.each do |atttached_atomes|
-          delete_recursive(atttached_atomes)
-        end
-        touch(:remove)
-        render(:delete, params)
-        Universe.delete(@id)
-      end
-    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} , #{attached}"
-  else
-    # alert grab(params).delete(true)
-    send(params, 0) unless params == :id
-  end
-end
-new({ particle: :clear, category: :utility, type: :boolean })
-
-new({ post: :clear }) do
-  attached_found = []
-  attached.each do |attached_id_found|
-    attached_found << attached_id_found
-  end
-  attached_found.each do |child_id_found|
-    child_found = grab(child_id_found)
-    # we exclude system  objects
-    child_found&.delete(true) unless child_found.tag && child_found.tag[:system]
-  end
-end
-new({ particle: :path, category: :utility, type: :string })
-new({ particle: :schedule, category: :utility, type: :string }) do |date, proc|
-  date = date.to_s
-  delimiters = [',', ' ', ':', '-']
-  format_date = date.split(Regexp.union(delimiters))
-  Universe.renderer_list.each do |renderer|
-    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
-    Essentials.new_default_params(params)
-    params_to_send = params
-  else
-    params_to_send = Essentials.default_params[params].dup
-    # we remove preset to avoid infinite loop
-    params_to_send.delete(:preset)
-    params_to_send.delete(:type)
-    params_to_send.each do |particle_found, value|
-      send(particle_found, value)
-    end
-    params_to_send = { params => params_to_send }
-  end
-  params_to_send
-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|
-  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
-new({ particle: :hypertext, category: :utility, type: :string })
-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: :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
-                else
-                  0
-                end
-  attached_atomes = []
-  attached_found = attached.dup
-  attached_found.each do |child_id_found|
-    child_found = grab(child_id_found)
-    if child_found
-      new_child = child_found.duplicate({})
-      attached_atomes << new_child.id
-    end
-  end
-  params[:attached] = attached_atomes
-  infos_found = infos.dup
-  keys_to_delete = [:history, :callback, :duplicate, :copy, :paste, :touch_code, :html, :attached, :aid]
-  keys_to_delete.each { |key| infos_found.delete(key) }
-  new_atome_id = "#{@id}_copy_#{copy_number}".to_sym
-  infos_found[:id] = new_atome_id
-  infos_found = infos_found.merge(params)
-  new_atome = Atome.new(infos_found)
-  @duplicate ||= {}
-  @duplicate[new_atome_id] = new_atome
-  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
-  if params == true
-    copies_found = all_copies.last
-  elsif params.instance_of? Integer
-    copies_found = all_copies[params.to_i]
-  elsif params.instance_of? Array
-    copies_found = [all_copies[params[0]][params[1]]]
-  end
-  new_atomes = []
-  applies_found = []
-  copies_found.each do |copy_found|
-    new_atome = grab(copy_found).duplicate({ attach: @id })
-    new_atomes << new_atome.id
-    # FIXME: below start to patch because apply is not apply , so we store it and apply it again
-    applies_found << new_atome.apply
-  end
-
-  # FIXME: end here the patch  because apply is not apply , so we store it and apply it again
-  new_atomes.each_with_index do |id_found, index|
-    grab(id_found).apply(applies_found[index])
-  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|
-    send(method, opt)
-  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 })
-

data/lib/atome/genesis/presets.rb

@@ -1,10 +0,0 @@
-
-new({preset: :box })
-
-new({preset: :circle })do |params = {},&bloc|
-
-  { type: :shape, width: 39, height: 39, smooth: '100%',
-            apply: [:circle_color],
-            left: 0, top: 0}
-end
-