atome 0.5.4.1.9 → 0.5.5.6.4

data/lib/renderers/html/identity.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+new({ renderer: :html, method: :id, type: :string })
+
+new({ method: :type, type: :string, renderer: :html }) do |_value, _user_proc|
+  html.shape(@id)
+end
+
+new({ method: :type, type: :string, renderer: :html, specific: :vector }) do |_value, _user_proc|
+  html.svg(@id)
+end
+
+new({ method: :type, type: :string, renderer: :html, specific: :image }) do |_value, _user_proc|
+  html.image(@id)
+end
+
+new({ method: :type, type: :string, renderer: :html, specific: :video }) do |_value, _user_proc|
+  html.video(@id)
+end
+
+new({ method: :type, type: :string, renderer: :html, specific: :www }) do |_value, _user_proc|
+  html.www(@id)
+end
+
+new({ method: :type, type: :string, renderer: :html, specific: :raw }) do |_value, _user_proc|
+  html.raw(@id)
+end
+
+new({ method: :type, type: :string, specific: :shape, renderer: :html }) do |_value, _user_proc|
+  html.shape(@id)
+end
+
+new({ method: :type, type: :string, specific: :text, renderer: :html }) do |_value, _user_proc|
+  html.text(@id)
+  html.add_class(:text)
+end
+
+new({ method: :type, type: :string, specific: :paint, renderer: :html }) do
+end
+
+new({ method: :type, type: :string, specific: :color, renderer: :html }) do
+end
+
+
+new({ method: :data, type: :string, specific: :text, renderer: :html }) do |value, _user_proc|
+  html.innerText(value)
+end
+
+new({ method: :data, type: :string, specific: :vector, renderer: :html }) do |value|
+  html.svg_data(value)
+end
+
+new({ method: :component, type: :hash, specific: :text, renderer: :html }) do |params, _user_proc|
+  params.each do |prop, value|
+    # we send component data directly to the text html renderer
+    send("html_text_#{prop}", value)
+  end
+end
+
+new({ method: :component, type: :hash, specific: :vector, renderer: :html }) do |params, _user_proc|
+  html.update_svg_data(params)
+end
+
+new({ method: :path, type: :string, renderer: :html }) do |value, _user_proc|
+  html.path(value)
+end
+
+new({ method: :path, type: :string, renderer: :html, specific: :image }) do |value, _user_proc|
+  html.path(value)
+end
+
+new({ method: :path, type: :string, renderer: :html, specific: :www }) do |value, _user_proc|
+  html.path(value)
+end
+
+new({ method: :data, type: :string, renderer: :html, specific: :raw }) do |value, _user_proc|
+  html.raw_data(value)
+end
+
+new({ renderer: :html, method: :category, type: :symbol }) do |category_names|
+  category_names.each do |category_name|
+    html.add_class(category_name)
+  end
+end

data/lib/renderers/html/index.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# require without relative is needed when using Opal
+
+require 'renderers/html/atome'
+require 'renderers/html/atome_html'
+require 'renderers/html/communication'
+require 'renderers/html/effect'
+require 'renderers/html/event'
+require 'renderers/html/geometry'
+require 'renderers/html/hierarchy'
+require 'renderers/html/html'
+require 'renderers/html/identity'
+require 'renderers/html/material'
+require 'renderers/html/property'
+require 'renderers/html//security'
+require 'renderers/html/spatial'
+require 'renderers/html//time'
+require 'renderers/html/utility'

data/lib/renderers/html/index_relative.rb

@@ -0,0 +1,20 @@
+
+# frozen_string_literal: true
+
+# relative is needed when using ruby wasm
+
+require_relative './atome'
+require_relative './atome_html'
+require_relative './communication'
+require_relative './effect'
+require_relative './event'
+require_relative './geometry'
+require_relative './hierarchy'
+require_relative './html'
+require_relative './identity'
+require_relative './material'
+require_relative './property'
+require_relative './/security'
+require_relative './spatial'
+require_relative './/time'
+require_relative './utility'

data/lib/renderers/html/material.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+new({ method: :overflow, renderer: :html, type: :string }) do |params, bloc|
+  html.overflow(params, bloc)
+end
+
+new({ method: :gradient, renderer: :html, type: :hash })
+
+new({ method: :remove, renderer: :html, type: :string }) do |object_id_to_remove, bloc|
+
+  if object_id_to_remove.instance_of? Hash
+    object_id_to_remove.each do |particle, value|
+      case particle
+      when :category
+        html.remove_class(value)
+      else
+        atome_ids_found = send(object_id_to_remove[:all])
+        atome_ids_found.each do |atome_id|
+          remove(atome_id)
+        end
+      end
+    end
+  else
+    atome_to_remove = grab(object_id_to_remove)
+    atome_type_found = atome_to_remove.type
+    case atome_type_found
+    when :color
+      if color == []
+        # we remove the last color set
+        html.style(:backgroundColor, :black)
+      else
+        html.style(:background, '')
+        html.style(:backgroundColor, '')
+        @apply.delete(object_id_to_remove)
+        apply(@apply)
+      end
+    when :shadow
+      html.style("boxShadow", 'none')
+      html.style("filter", 'none')
+      @apply.delete(object_id_to_remove)
+      apply(@apply)
+    when :paint
+      atome_to_remove = grab(object_id_to_remove)
+      atome_to_remove.gradient.each do |color_id|
+        html.style(:background, '')
+        html.style(:backgroundColor, '')
+        @apply.delete(color_id)
+      end
+      @apply.delete(object_id_to_remove)
+      apply(@apply)
+    end
+  end
+end

data/lib/renderers/html/property.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+new({ renderer: :html, method: :diffusion, type: :string })
+
+new({ method: :red, type: :integer, specific: :color, renderer: :html }) do |value, _user_proc|
+end
+
+new({ method: :green, type: :integer, specific: :color, renderer: :html }) do |value, _user_proc|
+end
+
+new({ method: :blue, type: :integer, specific: :color, renderer: :html }) do |value, _user_proc|
+end
+
+new({ method: :alpha, type: :integer, specific: :color, renderer: :html }) do |value, _user_proc|
+end
+
+
+new({ renderer: :html, method: :diffusion, type: :string })
+
+# edit
+new({ renderer: :html, method: :edit }) do |params|
+  html.attr(:contenteditable, params)
+  html.update_data(params)
+end

data/lib/renderers/html/spatial.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+new({ method: :top, type: :integer, renderer: :html }) do |params|
+  html.style(:top, "#{params}px")
+end
+
+new({ method: :top, type: :integer, renderer: :html, specific: :text }) do |params|
+  html.style(:top, "#{params}px")
+end
+new({ method: :top, type: :integer, renderer: :html, specific: :shadow })
+
+new({ method: :bottom, type: :integer, renderer: :html }) do |params|
+  html.style(:bottom, "#{params}px")
+end
+
+new({ method: :bottom, type: :integer, renderer: :html, specific: :text }) do |params|
+  html.style(:bottom, "#{params}px")
+end
+
+new({ method: :right, type: :integer, renderer: :html }) do |params|
+  html.style(:right, "#{params}px")
+end
+
+new({ method: :left, type: :integer, renderer: :html }) do |params|
+  html.style(:left, "#{params}px")
+end
+
+new({ method: :left, type: :integer, specific: :color, renderer: :html })
+
+new({ method: :left, type: :integer, renderer: :html, specific: :shadow })
+
+new({ method: :top, type: :integer, specific: :color, renderer: :html })
+
+new({ method: :rotate, type: :integer, renderer: :html }) do |params|
+  html.transform(:rotate, params)
+end
+
+new({ method: :rotate, type: :integer, renderer: :html, specific: :paint })
+
+new({renderer: :html, method: :position }) do |params|
+  html.style("position", params)
+end
+
+new({renderer: :html, method: :depth }) do |params|
+  html.style("z-index", params)
+end

data/lib/renderers/html/time.rb

@@ -0,0 +1 @@
+# frozen_string_literal: true

data/lib/renderers/html/utility.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+new({ renderer: :html, method: :web }) do |params, &user_proc|
+  params
+end
+
+new({ renderer: :html, method: :renderers, type: :string })
+new({ renderer: :html, method: :delete, type: :string }) do |params|
+  html.delete(id)
+end
+new({ renderer: :html, method: :hypertext }) do |params|
+  html.hypertext(params)
+end
+new({ renderer: :html, method: :hyperedit }) do |params|
+  html.hyperedit(params)
+end
+new({ renderer: :html, method: :read, type: :string }) do |value, &bloc|
+  html.read(id, value)
+end
+
+new({ renderer: :html, method: :browse, type: :string }) do |value, &bloc|
+  html.browse(id, value)
+end
+
+new({ renderer: :html, method: :terminal, type: :string }) do |value, &bloc|
+  html.terminal(id, value)
+end
+
+
+new({renderer: :html, method: :match}) do |params, bloc|
+  case id
+  when :atome || :view
+    result = bloc.call
+    result = { alterations: result }
+    params = params.merge(result)
+    html.match(params)
+  end
+end

data/lib/renderers/renderer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Rendering method here
+class Atome
+  # private
+
+  def render(element, params, &user_proc)
+
+    render_engines = @renderers
+    render_engines.each do |render_engine|
+      # in case we found an exception the method call will have the form, example for color top  : html_color_top
+      exception_found = "#{Universe.get_atomes_specificities[type][element]}"
+      send("#{render_engine}_#{exception_found}#{element}", params, &user_proc)
+    end
+  end
+end

data/lib/renderers/server/index.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# require without relative is needed when using Opal
+require 'renderers/server/utility'

data/lib/renderers/server/index_relative.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# relative is needed when using ruby wasm
+require_relative 'utility'

data/lib/renderers/server/utility.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+Genesis.build_render(:server_schedule)
+Genesis.build_render(:server_reader)

data/sig/atome.rbs

@@ -1,6 +1,8 @@
 module Atome
   VERSION: String
   # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  @store_allow: boolish
+
   def *: -> untyped
 
   def +: -> untyped
@@ -51,8 +53,12 @@ module Atome
 
   def get_row: -> untyped
 
+  def headless: -> untyped
+
   def matrix: -> untyped
 
+  def physical: -> untyped
+
   def ping: -> untyped
 
   def set: -> untyped

data/sig/object.rbs

@@ -1,3 +1,7 @@
 class Object
+  def atome_method_for_object: -> untyped
+
   def create_method_at_object_level: -> untyped
+
+  def new: -> untyped
 end

data/sig/universe.rbs

@@ -0,0 +1,3 @@
+class Universe
+  @specificities: untyped
+end

data/vendor/assets/Rakefile

@@ -1,3 +1,3 @@
-task :build do
-  `atome build;open src/index.html`
-end
+# task :build do
+#   `atome build`
+# end

data/vendor/assets/application/examples/a_concat.rb

@@ -0,0 +1,16 @@
+# Chemin du dossier contenant les fichiers
+folder_path = "./*"
+
+# Chemin du fichier de sortie
+output_file_path = "./!all.rb"
+
+# Création et ouverture du fichier de sortie
+File.open(output_file_path, "w") do |output_file|
+  # Lecture de tous les fichiers du dossier
+  Dir.glob(folder_path).each do |file_path|
+    # Lecture et écriture du contenu de chaque fichier
+    File.read(file_path).each_line do |line|
+      output_file.write(line)
+    end
+  end
+end

data/vendor/assets/application/examples/affect.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+box({ left: 12, id: :the_first_box })
+c=color({ id: :the_bananas, blue: 0.21, green: 1 })
+
+wait 1 do
+  c.affect(:the_first_box)
+end

data/vendor/assets/application/examples/animation.rb

@@ -0,0 +1,96 @@
+# # frozen_string_literal: true
+#
+# bb = text({ id: :the_ref, width: 369, data: "touch me!" })
+# bb.color(:orange)
+# box({ id: :my_box, drag: true })
+# c = circle({ id: :the_circle, left: 222, drag: { move: true, inertia: true, lock: :start } })
+# c.shadow({ renderers: [:html], id: :shadow2, type: :shadow,
+#            attach: [:the_circle],
+#            left: 3, top: 9, blur: 19,
+#            red: 0, green: 0, blue: 0, alpha: 1
+#          })
+#
+# Atome.new(animation: { renderers: [:browser], id: :the_animation1, type: :animation, attach: [],attached: []})
+# aa = animation({
+#                  targets: %i[my_box the_circle],
+#                  begin: {
+#                    left_add: 0,
+#                    top: :self,
+#                    smooth: 0,
+#                    width: 3
+#                  },
+#                  end: {
+#                    left_add: 333,
+#                    top: 299,
+#                    smooth: 33,
+#                    width: :the_ref
+#                  },
+#                  duration: 800,
+#                  mass: 1,
+#                  damping: 1,
+#                  stiffness: 1000,
+#                  velocity: 1,
+#                  repeat: 1,
+#                  ease: 'spring'
+#                }) do |pa|
+#   puts "animation say#{pa}"
+# end
+# aa.stop(true) do |val|
+#   puts " stop : #{val}"
+# end
+#
+# aa.start(true) do |val|
+#   puts " start : #{val}"
+# end
+#
+# bb.touch(true) do
+#   aa.play(true) do |po|
+#     puts "play say #{po}"
+#   end
+# end
+#
+# aaa = animation({
+#                   # no target for advanced animations control on callback
+#                   begin: {
+#                     left_add: 0,
+#                     top: :self,
+#                     smooth: 0,
+#                     width: 3
+#                   },
+#                   end: {
+#                     left_add: 333,
+#                     top: :self,
+#                     smooth: 33,
+#                     width: :the_ref
+#                   },
+#                   duration: 1800,
+#                   mass: 1,
+#                   damping: 1,
+#                   stiffness: 1000,
+#                   velocity: 1,
+#                   repeat: 1,
+#                   ease: 'spring'
+#                 }) do |pa|
+#   puts "get params to do anything say#{pa}"
+# end
+# wait 7 do
+#   aaa.play(true) do |po|
+#     puts "play aaa say #{po}"
+#   end
+# end
+
+#TODO : make the code above works
+# create a animation object
+# create callback methode when playing
+
+
+# here is how to animate shape :
+new({particle: :animate}) do |params|
+  html.play_animation({ from: 0, to: 300, duration: 1000 })
+end
+
+
+b=box({id: :the_box})
+
+b.animate(true)
+

data/vendor/assets/application/examples/apply.rb

@@ -0,0 +1,8 @@
+# # frozen_string_literal: true
+
+b=box({ left: 12, id: :the_first_box })
+color({ id: :the_lemon, red: 1, green: 1 })
+wait 1 do
+  b.apply(:the_lemon)
+end
+

data/vendor/assets/application/examples/atome.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Atome.new( { renderers: [:html], attach: [:view],id: :my_test_box, type: :shape, apply: [:shape_color],
+             left: 120, top: 0, width: 100, smooth: 15, height: 100, overflow: :visible, attached: [], center: true
+           })

data/vendor/assets/application/examples/attach.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Here is the attach explanation and example
+# the attach method in atome is both a getter and a setter
+# attach and attached particles serve the same purpose but just in the opposite direction
+# please note that atome.attach([:atome_id]) means that atome will be the parent of the atome with the id :atome_id
+# to sum up :  attach and attached are both setter and getter :
+# a.attach(b.ib) will attach the current object to the IDs passed in the params. The current atome will be the child of the the atomes width IDS passed in the the params,
+# a.attach(b.ib) means (insert 'o' into 'b') or a is parent b is child
+
+# while a.attached(b.id) (insert 'b' into 'a')is the opposite to attached it will attach IDs passed in the params to the current atome. The current atome will be the parent of of the the atomes width IDS passed in the the params
+# a.attached(b.ib) means (insert 'b' into 'a') or a is child b is parent
+
+# atome.attach([:atome_id]) means that atome will be the child of the atome with the id :atome_id
+# Here is how to use it as a setter :
+b = box({ id: :b315, color: :red })
+circle({ id: :c_12, top: 0, drag: true, color: :yellow })
+
+c=circle({ id: :c_123, color: :cyan, left: 233, drag: true })
+ box({ id: :b_1, left: 333, drag: true })
+grab(:b_1).attach(:c_123)
+
+bb = box({ top: 99, drag: true })
+bb.attach(:b_1)
+
+box({ id: :my_test_box })
+wait 1 do
+  b.attach(:c_12)
+  # Here is how to use it as a getter :
+  # to retrieve witch atomes b315 is attached to  to the atome c_12 just type
+  puts  b.attach # => [:c_12]
+  # to retrieve atome attached to the atome c_12 just type tha other method
+  puts  c.attached #=> [:b_1]
+end

data/vendor/assets/application/examples/attached.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+
+# Here is the attached explanation and example :
+
+# the attached method in atome is both a getter and a setter
+# attach and attached particles serve the same purpose but just in the opposite direction
+# please note that atome.attach([:atome_id]) means that atome will be the parent of the atome with the id :atome_id
+# to sum up :  attach and attached are both setter and getter :
+# attach will attach the current object to the IDs passed in the params. The current atome will be the child of the the atomes width IDS passed in the the params,
+# while attached is the opposite to attached it will attach IDs passed in the params to the current atome. The current atome will be the parent of of the the atomes width IDS passed in the the params
+
+
+# Here is how to use it as a setter :
+grab(:black_matter).color({ red: 1, green: 0.6, blue: 0.6, id: :active_color })
+grab(:black_matter).color({ red: 0.3, green: 1, blue: 0.3, id: :inactive_color })
+
+b = box({ left: 99, drag: true, id: :the_box })
+wait 1 do
+  b.apply([:active_color])
+end
+c = circle({ left: 333, id: :the_circle })
+wait 2 do
+  c.apply(:inactive_color)
+  b.attached([c.id])
+
+  # Here is how to use it as a getter :
+  # to retrieve witch atomes b315 is attached to  to the atome c_12 just type
+  puts  "c.attach#{c.attach}" # => [:the_box]
+  # to retrieve atome attached to the atome c_12 just type tha other method
+  puts  "b.attached : #{b.attached}" #=> [:the_circle]
+  puts "b.color : #{b.color}"
+  puts "c.color : #{c.color}"
+end
+
+
+
+

data/vendor/assets/application/examples/basic_understanding.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# The class Universe is used to  retrieve some data needed for the atome framework
+# per example you can retrieve the list of all available particles
+puts Universe.particle_list
+# this give at the date 14/11/2023 :
+# or the list of all available atomes
+puts Universe.atomes
+# this give at the date 14/11/2023 :
+# as well as the list of renderer available
+puts Universe.renderer_list
+# this give at the date 14/11/2023 :
+
+# Universe hold all these instance variable :
+
+# @counter is a integer  that store the total number of atome actually active for the current user on the current machine
+# @atomes = is a hash that contains  a list all atomes actually active for the current user on the current machine,
+# the key is the atome ID the value is the atome object itself
+# atomes_specificities
+# @atome_list is a hash that contains all atome's types available
+# @particle_list is a hash that contains all particle's types available
+# @renderer_list is an array that contains all renderers available
+# @specificities indicate to the atome framework witch atomes or particles have specificities, as all atomes and particles methods are define using lot of meta-programming, some atome and particle need special treatment, then we use specificities
+# @specificities is a hash where the key is either the atome type or the particle type and the value is a proc that hold the code to be executed when the specified atome is instantiated or the particle is applied onto the atome
+# @sanitizers  is a hash where the key is either the atome type or the particle type and the value is a proc holding the code to sanitize user input value before it's the value is interpreted , rendered and stored
+# @history is a hash that store the history of all modification of any atome's particle that happen on the current machine for current user.
+# the history hash is define as follow: the key is number of the operation  ( 0 is the first modification, 1 the second , and so on... )
+# that value of the history hash contain also another hash define as follow: the key is the id of the atome altered and the value is again a new hash with three keys :
+# on of the three keys is sync , the sync value hold the sync state of the alteration (sync true means that the alteration is stored and backup on a server), another keys is time, its value hold the time stamp of the alteration
+# the third key is the particle altered and value is the new value of the particle
+# @users = is a hash that contains all user session on the current machine
+
+# basic usage:
+# # we create a basic empty atome
+a=Atome.new
+# we add a bunch particles
+a.renderers([:html])
+a.id(:my_shape)
+a.type(:shape)
+a.width(33)
+a.height(33)
+a.top(33)
+a.left(33)
+# we can now add a color the atome using  apply  used to apply an atome onto another (please note that color is also an atome not a particle)
+# in this case  we apply the color atome name box_color this a default color created by the system
+a.apply([:box_color])
+wait 2 do
+  # a bit less efficient and a bit more processor intensive solution is to use the box preset, that render a box too
+  b=box
+  # we can add a color atome onto the new atome my_shape. as stated before for some atome types such as color, shadows ,the relation between the two atomes won't be attach and attached but  apply and affect instead the atome color with the particle red onto the
+  b.color(:red)
+end

data/vendor/assets/application/examples/browse.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+
+# browse only works with  application version of atome or using server mode , it allow the browse local file on your computer or remote file on server, if operating in server mode
+
+# here is an example :
+A.browse('/') do |data|
+  text "folder content  :\n #{data}"
+end
+
+# if Atome.host == 'tauri'
+#   # JS.eval("readFile('atome','Cargo.toml')")
+#   JS.eval("browseFile('atome','/')")
+# else
+#   puts 'nothing here'
+#   # JS.eval("terminal('A.terminal_callback','pwd')")
+# end