atome 0.5.4.1.9 → 0.5.5.6.4

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

@@ -0,0 +1,31 @@
+# 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 }) do
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
+end
+new({ particle: :green }) do
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
+end
+new({ particle: :blue }) do
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
+end
+new({ particle: :alpha }) do
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
+end
+new({ particle: :diffusion }) do
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+new ({ particle: :password })
+new ({ sanitizer: :password }) do |params|
+
+  params = { read: params, write: params } unless params.instance_of? Hash
+
+  # encoding below
+  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|
+  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

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

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-new({ particle: :left, type: :integer }) do |_params, user_proc|
-  instance_exec(&user_proc) if user_proc.is_a?(Proc)
-end
+new({ particle: :left, type: :integer })
 new({ particle: :right, type: :integer })
 new({ particle: :top, type: :integer })
 new({ particle: :bottom, type: :integer })
 new({ particle: :rotate, type: :integer })
 new({ particle: :direction, type: :string })
 new({ particle: :center, type: :string})
-new ({particle: :depth, type: :integer})
-
+new({particle: :depth, type: :integer})
+new({ particle: :position })

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
 
-generator = Genesis.generator
 # create particles
 new({ particle: :markers, type: :hash })

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

@@ -3,89 +3,76 @@
 new({ particle: :renderers })
 new({ particle: :code })
 new({ particle: :run }) do |params|
-  code_found = @atome[:code]
+  code_found = @code
   instance_exec(params, &code_found) if code_found.is_a?(Proc)
 end
-new({ particle: :broadcast })
-new({ particle: :data })
-# new({particle: :additional })
-new({ particle: :delete, render: false }) do |params, &user_proc|
+# 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, 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]
+    unless @tag && (@tag[:persistent] || @tag[:system])
       # now we detach the atome from it's parent
       # now we init rendering
-      rendering(:delete, params, &user_proc)
+      render(:delete, params)
       # the machine delete the current atome from the universe
-      id_found = @atome[:id]
-      Universe.delete(id_found)
-      parents_found = @atome[:attach]
-      parents_found.each do |parent_id_found|
-        parent_found = grab(parent_id_found)
-        next unless parent_found
-
-        previous_parent_type_child = parent_found.atome[type]
-        previous_parent_attached_child = parent_found.atome[:attached]
-        # FIXME : find why we can't use delete on the array nut must use an iterator
-        new_type_container = []
-        previous_parent_type_child.each do |atome_found|
-          new_type_container << atome_found unless atome_found == id_found
-        end
-        parent_found.atome[type] = new_type_container
-        # FIXME : find why we can't use delete on the array nut must use an iterator
-        new_attached_container = []
-        previous_parent_attached_child.each do |atome_found|
-          new_attached_container << atome_found unless atome_found == id_found
-        end
-        parent_found.atome[:attached] = new_attached_container
-
-      end
-
+      id_found = @id.to_sym
+      parent_found = grab(@attach)
+      parent_found.attached.delete(id_found)
     end
+  elsif params.instance_of? Hash
 
-  elsif params == :materials
-    # this will delete any child with a visual type cf : images, shapes, videos, ...
-    materials.each do |atome_id_found|
-      grab(atome_id_found).delete(true)
-    end
-  elsif params[:id]
-    # the machine try to an atome by it's ID and delete it
-    # We check for recursive, if found we delete attached atomes too
-    if params[:recursive] == true
-      materials_found = grab(params[:id]).materials
-      materials_found.each do |atome_id_found|
-        grab(atome_id_found).delete(true)
+    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
-    grab(params[:id]).delete(true)
-  elsif params.instance_of? Hash
-    # 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
+
+  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
-    send(params, 0)
+    send(params, 0) unless params == :id
   end
 end
-
 new({ particle: :clear })
 new({ post: :clear }) do
-
   attached_found = []
-  @atome[:attached].each do |attached_id_found|
+  attached.each do |attached_id_found|
     attached_found << attached_id_found
   end
   attached_found.each do |child_id_found|
-    # puts "===>> should be deleted : #{child_id_found}"
     child_found = grab(child_id_found)
-
-    child_found.delete(true) if child_found
-
-    # Universe.delete(child_id_found)
+    # we exclude system  objects
+    child_found&.delete(true) unless child_found.tag && child_found.tag[:system]
   end
-  # attached([])
-  # puts "params are => #{id}"
 end
 new({ particle: :path })
 new({ particle: :schedule }) do |date, proc|
@@ -102,13 +89,141 @@ new({ particle: :read }) do |file, proc|
   end
 end
 new({ particle: :cursor })
-new({ particle: :preset })
+
+new({ particle: :preset }) 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, type: :hash })
 new({ particle: :tag, render: false, type: :hash })
-new({ particle: :batch, render: false })
-new({ sanitizer: :batch }) do |params|
-  Batch.new(params)
-  # puts "index msg : we must treat the batch : #{params}"
+new({ particle: :web })
+new({ particle: :unit, type: :hash })
+new({ initialize: :unit, value: {} })
+new({ particle: :login }) do |params|
+  set_current_user(id) if params
+end
+new({ particle: :hypertext })
+new({ particle: :hyperedit })
+new({ particle: :terminal })
+new({ particle: :read })
+new({ particle: :browse })
+new({ particle: :copies })
+new({ particle: :temporary })
+new({ particle: :atomes })
 
+new({ particle: :match }) do |params, _bloc|
+  params
+end
+
+new({ sanitizer: :match }) do |params, _bloc|
+  params[:condition] = { min: { width: 0 } } unless params[:condition]
+  params
+end
+
+new({ particle: :invert })
+new({ particle: :option })
+
+new({ particle: :duplicate, store: false }) do |params|
+  copy_number = if @duplicate
+                  @duplicate.length
+                else
+                  0
+                end
+  new_atome_id = "#{@id}_copy_#{copy_number}"
+  new_atome = Atome.new({ type: @type, renderers: @renderers, id: new_atome_id })
+
+  attached_atomes = []
+  attached_found = attached.dup
+  particles_found = instance_variables.dup
+
+  keys_to_delete = [:@history, :@callback, :@duplicate, :@copy, :@paste, :@touch_code, :@html, :@attached, :@id]
+  keys_to_delete.each { |key| particles_found.delete(key) }
+  params[:id] = new_atome_id
+
+  particles_found.each do |particle_found|
+    particle_name = particle_found.to_s.sub('@', '')
+
+    particle_content = self.send(particle_name)
+    # FIXME: find a better to attach object when false is found
+    particle_content = :view if particle_content == false
+    new_atome.set(particle_name => particle_content)
+    # new_atome.instance_variable_set('@touch_code',touch_code)
+  end
+
+  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
+  # FIXME: below  dunno why we have to add this manually
+  new_atome.height(@height)
+  new_atome.width(@width)
+  if params.instance_of? Hash
+    params.each do |k, v|
+      new_atome.send(k, v)
+    end
+  end
+
+  @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 }) do |items_id|
+  unless items_id.instance_of? Array
+    items_id = [items_id]
+  end
+  grab(:copy).collect << items_id
+end
+
+
+new({ particle: :paste }) 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

data/lib/atome/genesis/genesis.rb

@@ -3,71 +3,168 @@
 # allow to access Atome class using only a uniq atome
 class Genesis
   class << self
-    def generator
-      Atome.new
+
+    def create_particle(element, store, render)
+      Atome.define_method "set_#{element}" do |params, &user_proc|
+       particle_creation(element, params, store, render, &user_proc)
+      end
     end
-  end
-end
 
-# Genesis method here
-class Atome
-  def build_particle(particle_name, options = {}, &particle_proc)
-    type = options[:type]
-    type = :string if options[:type].nil?
-    store = options[:store]
-    store = true if options[:store].nil?
-    render = options[:render]
-    render = true if options[:render].nil?
-
-    # we add the new method to the particle's collection of methods
-    Universe.add_to_particle_list(particle_name, type)
-    # the line below create an empty particle method for each renderer, eg: browser_left, headless_width, ...
-    # the line below create the corresponding particle method for Batch class
-    particle_method_for_batch(particle_name)
-    auto_render_generator(particle_name) if render
-    new_particle(particle_name, store, render, &particle_proc)
-    # the line below create all alternatives methods such as create 'method='
-    additional_particle_methods(particle_name, store, render, &particle_proc)
-  end
+    def build_particle(particle_name, options = {}, &particle_proc)
+      type = options[:type]
+      type = :string if options[:type].nil?
+      store = options[:store]
+      store = true if options[:store].nil?
+      render = options[:render]
+      render = true if options[:render].nil?
 
-  def build_atome(atome_name, &atome_proc)
-    # TODO : atomes should tell the Universe if they're parts of materials category or else
-    # we add the new method to the atome's collection of methods
-    Universe.add_to_atome_list(atome_name)
-    # the method below generate Atome method creation at Object level,
-    # so a syntax like : 'text(:hello)' is possible instead of the mandatory : grab(:view).text(:hello)
-    atome_method_for_object(atome_name)
-    # the line below create the corresponding atome method for Batch class
-    atome_method_for_batch(atome_name)
-    unless Essentials.default_params[atome_name]
-      # if it doesn't exist
-      # we create default params for the new created atome, adding the hash to : module essential, @default_params
-      Essentials.new_default_params(atome_name => { type: atome_name, attach: [:view] })
+      # we add the new method to the particle's collection of methods
+      Universe.add_to_particle_list(particle_name, type)
+      # the line below create an empty particle method for each renderer, eg: browser_left, headless_width, ...
+      # the line below create the corresponding particle method for Batch class
+      # particle_method_for_batch(particle_name)
+      auto_render_generator(particle_name) if render
+      new_particle(particle_name, store, render, &particle_proc)
+      # the line below create all alternatives methods such as create 'method='
+      additional_particle_methods(particle_name, store, render, &particle_proc)
     end
 
-    # the line below create an empty atome method for each renderer, eg: browser_shape, headless_color, ...
-    auto_render_generator(atome_name)
-    # create_atome(atome_name)
-    new_atome(atome_name, &atome_proc)
+    def build_atome(atome_name, &atome_proc)
+      # we add the new method to the atome's collection of methods
+      Universe.add_to_atome_list(atome_name)
+      # the method below generate Atome method creation at Object level,
+      # so a syntax like : 'text(:hello)' is possible instead of the mandatory : grab(:view).text(:hello)
+      atome_method_for_object(atome_name)
+      # the line below create the corresponding atome method for Batch class
+      # atome_method_for_batch(atome_name)
+      unless Essentials.default_params[atome_name]
+        # we create default params for the new created atome, adding the hash to : module essential, @default_params
+        # FIXME : the hash : attach: [:view] means that newly atome will systematically be attached to the wview instaed of the parent:
+        # ex : b.www will attach to view not b!
+        Essentials.new_default_params(atome_name => { type: atome_name })
+      end
 
-  end
+      # the line below create an empty atome method for each renderer, eg: browser_shape, headless_color, ...
+      auto_render_generator(atome_name)
+      new_atome(atome_name, &atome_proc)
 
-  def auto_render_generator(element)
-    Universe.renderer_list.each do |render_engine|
-      build_render("#{render_engine}_#{element}")
     end
-  end
 
-  def build_render(renderer_name, &method_proc)
-    new_render_engine(renderer_name, &method_proc)
-  end
+    def auto_render_generator(element)
+      Universe.renderer_list.each do |render_engine|
+        build_render("#{render_engine}_#{element}",)
+      end
+    end
 
-  def build_sanitizer(method_name, &method_proc)
-    Universe.add_sanitizer_method(method_name.to_sym, &method_proc)
-  end
+    def build_render(renderer_name, &method_proc)
+      Atome.define_method renderer_name do |params = nil, &user_proc|
+        instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
+      end
+    end
+
+    def build_sanitizer(method_name, &method_proc)
+      Universe.add_sanitizer_method(method_name.to_sym, &method_proc)
+    end
+
+    def build_option(method_name, method_proc)
+      Universe.add_optional_method(method_name.to_sym, method_proc)
+    end
+
+    def new_particle(element, store, render, &_method_proc)
+      Atome.define_method element do |params = nil, &user_proc|
+        @history[element] ||= []
+        if (params || params == false) && write_auth(element)
+          params = particle_sanitizer(element, params, &user_proc)
+          # the line below execute the main code when creating a new particle
+          # ex : new({ particle: :my_particle } do....
+          # instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
+          Genesis.create_particle(element, store, render)
+          # TODO: try to optimise and find a better way wo we can remove the condition below
+          if @type == :group && !%i[type id collect layout].include?(element)
+            collect.each do |collected_found|
+              grab(collected_found).send(element, params, &user_proc)
+            end
+          end
+
+          computed_params= send("set_#{element}", params, &user_proc) # sent to : create_particle / Atome.define_method "set_#{element}"
+
+          # we historicize all write action below
+          # we add the changes to the stack that must be synchronised
+          Universe.historicize(@id, :write, element, params)
+          computed_params
+        elsif params || params == false
+          "send a valid password to write #{element} value"
+        elsif read_auth(element)
+          # particle getter below
+          value_found = instance_variable_get("@#{element}")
+          # uncomment below to  historicize all read action
+          # Universe.historicize(@id, :read, element, value_found)
+          # we add the optional read plugin
+          value_found = particle_read(element, value_found, &user_proc)
+          value_found
+          # TODO : create a fast method to get particle: eg:
+          #  Atome.define_method "set_#{element}" ... =>  send("set_#{element}"
+        else
+          "send a valid password to read #{element} value"
+        end
+
+      end
+    end
+
+    def additional_particle_methods(element, store, rendering, &method_proc)
+      # it allow the creation of method like top=, rotate=, ...
+      Atome.define_method "#{element}=" do |params = nil, &user_proc|
+        instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
+        params = particle_sanitizer(element, params)
+        particle_creation(element, params, store, rendering, &user_proc)
+      end
+    end
+
+    def new_atome(element, &method_proc)
+
+      # the method define below is the slowest but params are analysed and sanitized
+      Atome.define_method element do |params = nil, &user_proc|
+        instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
+        if params
+          params = atome_sanitizer(element, params, &user_proc)
+          atome_processor(element, params, &user_proc)
+        else
+          # when no params passed whe assume teh user want a getter,
+          # as getter should give us all atome of a given within the atome
+          # ex : puts a.shape => return all atome with the type 'shape' in this atome
+          collected_atomes = []
+          # attached.each do |attached_atome|
+          #   collected_atomes << attached_atome if grab(attached_atome).type.to_sym == element.to_sym
+          # end
+          # TODO : add category for atome( material/physical vs modifier : color, shadow, .. vs shape, image ..)
+          # then add condition same things fo code in presets/atome atome_common
+          if %i[color shadow paint].include?(element)
+            # we do the same for apply to be able to retrieve 'color' and other atome that apply instead of being attached
+            apply.each do |attached_atome|
+              collected_atomes << attached_atome if grab(attached_atome).type.to_sym == element.to_sym
+            end
+          else
+            # collected_atomes = attached
+            attached.each do |attached_atome|
+              collected_atomes << attached_atome if grab(attached_atome).type.to_sym == element.to_sym
+            end
+          end
+          collected_atomes
+        end
+      end
+
+      # the method define below is the fastest params are passed directly
+      Atome.define_method "set_#{element}" do |params, &user_proc|
+        # we generate the corresponding module here:
+        # Object.const_set(element, Module.new)
+        # we add the newly created atome to the list of "child in it's category, eg if it's a shape we add the new atome
+        # to the shape particles list : @!atome[:shape] << params[:id]
+        Atome.new(params, &user_proc)
+        # Now we return the newly created atome instead of the current atome that is the parent cf: b=box; c=b.circle
+      end
+
+    end
 
-  def build_option(method_name, &method_proc)
-    #puts "2 => #{method_name}"
-    Universe.add_optional_method(method_name.to_sym, &method_proc)
   end
+
 end