atome 0.5.4.1.9 → 0.5.5.6.5

data/lib/atome/kernel/universe.rb

@@ -2,31 +2,35 @@
 
 # universe method here
 class Universe
-  @counter=0
+  @counter = 0
   @atomes = {}
-  @classes = {}
   @atome_list = []
   @particle_list = {}
-  @renderer_list = %i[html browser headless server]
-  @options = {}
+  @renderer_list = %i[html browser headless server log]
   @sanitizers = {}
+  @specificities = {}
+  @history = {}
+  @users = {}
+
   class << self
-    attr_reader :atomes, :renderer_list, :atome_list, :particle_list, :classes, :counter
+    attr_reader :atomes, :renderer_list, :atome_list, :particle_list, :classes, :counter, :atomes_specificities
 
     def add_to_particle_list(particle = nil, type)
-      instance_variable_get('@particle_list')[particle]=type
+      instance_variable_get('@particle_list')[particle] = type
     end
 
-    def add_optional_method(method_name, &method_proc)
-      # this method is used to add optional methods
-      # puts "3 => #{method_name}"
-      instance_variable_get('@options').merge!({ method_name => method_proc })
-      # puts "====> #{instance_variable_get('@options')[method_name]}"
+    def add_atomes_specificities atome_type_to_add
+      @specificities[atome_type_to_add] = {}
     end
 
-    def get_optional_method(method_name)
-      # this method is used to add optional methods
-      instance_variable_get('@options')[method_name]
+    def set_atomes_specificities params
+      particle_found = params[:method].to_sym
+      specificity = "#{params[:specific]}_".to_sym
+      @specificities[params[:specific]][particle_found] = specificity
+    end
+
+    def get_atomes_specificities
+      @specificities
     end
 
     def add_sanitizer_method(method_name, &method_proc)
@@ -44,9 +48,8 @@ class Universe
     end
 
     def add_to_atomes(id, atome)
-      # instance_variable_get('@atomes').merge!(atome)
       @atomes[id] = atome
-      @counter=@counter+1
+      @counter = @counter + 1
     end
 
     def update_atome_id(id, atome, prev_id)
@@ -54,6 +57,26 @@ class Universe
       @atomes.delete(prev_id)
     end
 
+    def user_atomes
+      collected_id = []
+      @atomes.each do |id_found, atome_found|
+        unless atome_found.tag && atome_found.tag[:system]
+          collected_id << id_found
+        end
+      end
+      collected_id
+    end
+
+    def system_atomes
+      collected_id = []
+      @atomes.each do |id_found, atome_found|
+        if atome_found.tag && atome_found.tag[:system]
+          collected_id << id_found
+        end
+      end
+      collected_id
+    end
+
     def app_identity
       # each app hav its own identity, this allow to generate new user identities from th
       @app_identity = 369
@@ -79,29 +102,105 @@ class Universe
       platform
     end
 
-    def current_machine
+    def platform_type
+      case RUBY_PLATFORM
+      when /win/i
+        "Windows"
+      when /darwin/i
+        "macOS"
+      when /linux/i
+        "Linux"
+      when /unix/i
+        "Unix"
+      else
+        "Plate-forme inconnue"
+      end
+    end
+
+    def engine
       platform = RUBY_PLATFORM.downcase
-      output = `#{platform =~ /win32/ ? 'ipconfig /all' : 'ifconfig'}`
+      output = if platform == :opal
+                 platform = JS.global[:navigator][:userAgent].to_s.downcase
+                 platform.include?('win32') ? 'ipconfig /all' : 'ifconfig'
+                 # `#{platform =~ /win32/ ? 'ipconfig /all' : 'ifconfig'}`
+               elsif platform == 'wasm32-wasi'
+                 'ifconfig'
+               elsif platform_type == :windows
+                 'ipconfig'
+               else
+                 'ifconfig'
+               end
       current_machine_decision(platform, output)
       # TODO: check the code above and create a sensible identity
     end
 
+    def current_server
+      return unless RUBY_ENGINE.downcase == 'opal' # Remplacez 'atome' par la valeur correcte pour votre environnement Atome
+      JS.global[:location][:href].to_s
+
+    end
+
     def current_user
       @user
     end
 
-    def current_server
-      `window.location.href` if RUBY_ENGINE.downcase == 'opal'
+    def add_user=(id)
+      @users[id] = true
     end
 
-    def current_user=(user)
+    def users
+      @users
+    end
+
+    def current_user=(user_id)
       # TODO: create or load an existing user
       # if user needs to be create the current_user will be eVe
-      @user = user
+      @user = user_id
+    end
+
+    def current_machine
+      @machine
     end
 
-    def connected
-      true
+    def current_machine=(machine_id)
+      # TODO: create or load an existing user
+      # if user needs to be create the current_user will be eVe
+      @machine = machine_id
+    end
+
+    def internet
+      if RUBY_ENGINE.downcase != :native
+        grab(:view).html.internet
+      else
+        # write code here for native
+      end
     end
+
+    def synchronised(action_nb, pass)
+      return unless Black_matter.encode(pass) == Black_matter.password[:read][:atome]
+
+      @history[action_nb][:sync] = true
+    end
+
+    def historicize(id, operation, element, params)
+      @history[@history.length] = { id => { operation => { element => params } }, sync: false, time: Time.now }
+    end
+
+    def story(filter)
+      # 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

data/lib/atome/presets/atome.rb

@@ -5,51 +5,55 @@
 # TODO: Factorise codes below
 # TODO we must clarified/unified the usage of presets and sanitizer it is not clear
 
+# additional Atome methods
 class Atome
-  def atome_common(atome_type, params)
-    # TODO : optimise the whole code below and make it rubocop friendly
-    essential_params = Essentials.default_params[atome_type] || {}
-    essential_params[:type] = essential_params[:type] || :element
-    essential_params[:renderers] = essential_params[:renderers] || @atome[:renderers]
-    essential_params[:id] = params[:id] || identity_generator(atome_type)
-    essential_params[:attach] = params[:attach] || [@atome[:id]] || [:view]
-    if params[:definition]
-      # if it is a vector we reorder tha params
-      attached = params.delete(:attached)
-      params = params.merge({ attached: attached })
+  def atome_common(atome_preset, params)
+    basic_params = { renderers: [] }
+    # TODO : remove Essentials.default_params[atome_preset] || {} as it is
+    # applied twice because preset is now a particle
+    preset_params = Essentials.default_params[atome_preset] || {}
+
+    basic_params[:type] = preset_params[:type] || :element
+    basic_params[:id] = params[:id] || identity_generator(atome_preset)
+    basic_params[:renderers] = @renderers || preset_params[:renderers]
+    essential_params = basic_params.merge(preset_params)
+    reordered_params = essential_params.reject { |key, _| params.has_key?(key) }
+    params = reordered_params.merge(params)
+
+    # condition to handle color/shadow/paint atomes that shouldn't be attach to view
+    # TODO : add category for atome( material/physical vs modifier : color, shadow, .. vs shape, image ..)
+    # then add condition same things fo code in genesis new_atome
+    if %i[color shadow paint].include?(atome_preset)
+      unless params[:affect]
+        params[:affect] = if @id == :view
+                            [:black_matter]
+                          else
+                            [@id]
+                          end
+      end
+    else
+      params[:attach] = params[:attach] || @id || :view
     end
+    params
+  end
 
-
-    essential_params.merge(params)
+  def preset_common(params, &bloc)
+    # if an atome with current id exist we update the ID in the params
+    params[:id] = "#{params[:id]}_#{Universe.atomes.length}" if grab(params[:id])
+    Atome.new(params, &bloc)
   end
 
   def box(params = {}, &bloc)
-    atome_type = :box
-    params = atome_common(atome_type, params)
-    # b= send(params[:type],params , &bloc)
-  Atome.new({ atome_type => params }, &bloc)
-
+    atome_preset = :box
+    params = atome_common(atome_preset, params)
+    preset_common(params, &bloc)
   end
 
-
-
   def circle(params = {}, &bloc)
-    atome_type = :circle
-    params = atome_common(atome_type, params)
-    # send(params[:type],params , &bloc)
-    Atome.new({ atome_type => params }, &bloc)
+    atome_preset = :circle
+    params = atome_common(atome_preset, params)
+    preset_common(params, &bloc)
   end
-
-
-  def vector(params = {}, &bloc)
-    atome_type = :vector
-    params = atome_common(atome_type, params)
-    # send(params[:type],params, &bloc )
-    Atome.new({ atome_type => params }, &bloc)
-
-
-  end
-
 end
 
 

data/lib/atome/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+#  return atome version
 class Atome
-  VERSION = '0.5.4.1.9'
-end
+  VERSION = '0.5.5.6.5'
+end

data/lib/atome.rb

@@ -1,37 +1,37 @@
 # frozen_string_literal: true
 
+
+# require without relative is needed when using Opal
 require 'fileutils'
 require 'securerandom'
 require 'atome/version'
 require 'atome/genesis/genesis'
-require 'atome/kernel/essentials'
+require 'atome/kernel/black_matter'
 require 'atome/kernel/universe'
-require 'atome/kernel/batch'
 require 'atome/helpers/essentials'
-require 'atome/renderers/renderer'
+require 'renderers/renderer'
 require 'atome/helpers/color_helper/color'
 require 'atome/extensions/atome'
-require 'atome/extensions/mathematic'
+require 'atome/extensions/mathematics'
 require 'atome/atome'
-require 'atome/helpers/callbacks'
 require 'atome/genesis/generators/atome'
 require 'atome/presets/atome'
 require 'atome/genesis/generators/communication'
 require 'atome/genesis/generators/effect'
 require 'atome/genesis/generators/event'
 require 'atome/genesis/generators/geometry'
+require 'atome/genesis/generators/hierarchy'
 require 'atome/genesis/generators/identity'
 require 'atome/genesis/generators/material'
+require 'atome/genesis/generators/property'
+require 'atome/genesis/generators/security'
 require 'atome/genesis/generators/spatial'
 require 'atome/genesis/generators/time'
 require 'atome/genesis/generators/utility'
 require 'atome/helpers/utilities'
-if RUBY_ENGINE.downcase == 'opal'
-  require 'atome/renderers/browser/browser'
-  require 'atome/renderers/html/html'
-end
-require 'atome/renderers/headless/headless'
-require 'atome/renderers/server/server'
-require 'atome/extensions/matrix'
+require 'atome/helpers/security'
+require 'renderers/html/index'
+require 'renderers/headless/index'
+require 'renderers/server/index'
 require 'atome/helpers/sanitizer'
 require 'atome/genesis/sparkle'

data/lib/atome_relative.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# relative is needed when using ruby wasm
+require 'fileutils'
+require 'securerandom'
+require_relative './atome/version'
+require_relative './atome/genesis/genesis'
+require_relative 'atome/kernel/black_matter'
+require_relative './atome/kernel/universe'
+require_relative './atome/helpers/essentials'
+require_relative './renderers/renderer'
+require_relative './atome/helpers/color_helper/color'
+require_relative './atome/extensions/atome'
+require_relative './atome/extensions/mathematics'
+require_relative './atome/atome'
+require_relative './atome/genesis/generators/atome'
+require_relative './atome/presets/atome'
+require_relative './atome/genesis/generators/communication'
+require_relative './atome/genesis/generators/effect'
+require_relative './atome/genesis/generators/event'
+require_relative './atome/genesis/generators/geometry'
+require_relative './atome/genesis/generators/hierarchy'
+require_relative './atome/genesis/generators/identity'
+require_relative './atome/genesis/generators/material'
+require_relative './atome/genesis/generators/property'
+require_relative './atome/genesis/generators/security'
+require_relative './atome/genesis/generators/spatial'
+require_relative './atome/genesis/generators/time'
+require_relative './atome/genesis/generators/utility'
+require_relative './atome/helpers/utilities'
+require_relative './atome/helpers/security'
+require_relative './renderers/html/index_relative'
+require_relative './renderers/headless/index_relative'
+require_relative './renderers/server/index_relative'
+require_relative './atome/helpers/sanitizer'
+require_relative './atome/genesis/sparkle'

data/lib/{atome/renderers → platform_specific}/opal/atome_opal_extensions.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
-require 'extensions/atome'
+require 'extensions/object'
+require 'extensions/js'
 require 'extensions/geolocation'
 require 'extensions/ping'
 require 'extensions/sha'
 require 'extensions/color'
+require 'native'
+

data/lib/{atome/renderers → platform_specific}/opal/extensions/color.rb

@@ -3,11 +3,18 @@
 # rgb utility
 class Atome
   def rgb_html(string)
-    `
-  col = w3color(#{string});
-  rgb_col=col.toRgb();
-  return Opal.hash(rgb_col)
- `
+    #    `
+    #  col = w3color(#{string});
+    #  rgb_col=col.toRgb();
+    #  return Opal.hash(rgb_col)
+    # `
+    js_code = <<-JS
+  var col = w3color('#{string}');
+  var rgb_col = col.toRgb();
+  return rgb_col;
+    JS
+
+    JS.eval(js_code)
   end
 
   def to_rgb(string)

data/lib/{atome/renderers → platform_specific}/opal/extensions/geolocation.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 class Atome
   def geolocation

data/lib/platform_specific/opal/extensions/js.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# JS add on specific to Opal
+module JS
+
+  def self.eval(string)
+    clean_str = string.gsub('return', '')
+    result = `eval(#{clean_str})`
+    native_result = Native(result)
+    native_result
+  end
+
+  def self.global
+    JS.eval('window')
+  end
+
+end
+
+
+
+

data/lib/platform_specific/opal/extensions/object.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# main add on
+def alert(val)
+  JS.eval("alert('#{val}')")
+end

data/lib/platform_specific/opal/extensions/ping.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Add on the Atome class
+class Atome
+  def ping(my_proc = false)
+    instance_exec(my_proc) if my_proc.is_a?(Proc)
+#     ` var p = new Ping();
+#         p.ping('https://'+#{address}+'', function (err, data) {
+#             if (err) {
+#                return false;
+#             } else {
+#  console.log("the site "+#{address}+" is up!");
+#             }
+#         });
+# `
+    js_code = <<-JS
+var p = new Ping();
+p.ping('https://' + "#{address}" + '', function (err, data) {
+    if (err) {
+       return false;
+    } else {
+       console.log("the site " + "#{address}" + " is up!");
+    }
+});
+JS
+
+    # Exécute le code JavaScript
+    JS.eval(js_code)
+
+  end
+end

data/lib/{atome/renderers → platform_specific}/opal/extensions/sha.rb

@@ -3,8 +3,10 @@
 # addon for the Atome class
 class Atome
   def calculate_sha(string)
-    if RUBY_ENGINE.downcase == 'opal'
-      `sha256(#{string})`
+    if RUBY_ENGINE.downcase == 'opal' || 'wasm32-wasi'
+      # `sha256(#{string})`
+      js_code = "sha256('#{string}')"
+      JS.eval(js_code)
     else
       Digest::SHA256.hexdigest(string)
     end

data/lib/platform_specific/wasm/atome_wasm_extensions.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+def alert(val)
+  escaped_val = val.to_s.gsub("'", "\\'").gsub("\n", "\\n")
+  JS.eval("alert('#{escaped_val}')")
+end
+
+# dummy object to allow code parity with Opal when using Native Object with wasm
+def Native(obj)
+  obj
+end

data/lib/renderers/headless/headless.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+# add renderer html to atome
+
+# headless rendering for atome
+class Atome
+  def headless(_val = nil); end
+end
+
+#  this class is aimed at headless rendering
+class Headless
+
+  def initialize(id_found, current_atome)
+    @element ||= self
+    @id = id_found
+    @original_atome = current_atome
+  end
+
+end

data/lib/renderers/headless/index.rb

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

data/lib/renderers/headless/index_relative.rb

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

data/lib/renderers/headless/utility.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# generator = Genesis.generator
+
+Genesis.build_render(:headless_schedule)
+Genesis.build_render(:headless_reader)

data/{vendor/assets/src/medias/rubies/examples/top.rb → lib/renderers/html/atome.rb}

@@ -1,4 +1,3 @@
 # frozen_string_literal: true
 
-box({top: 120 })
 

data/lib/renderers/html/atome_html.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Atome
+  def html(obj = nil)
+    if obj
+      @html = obj
+    else
+      @html
+    end
+  end
+
+  def to_px(particle)
+    ruby_wasm_code = <<-JS
+  var div = document.getElementById("#{@id}");
+  var style = window.getComputedStyle(div);
+  var original_value = style.getPropertyValue("#{particle}");
+  var parsed_value = parseInt(original_value);
+  return parsed_value;
+    JS
+    JS.eval(ruby_wasm_code).to_f
+  end
+end

data/lib/renderers/html/effect.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+new({ renderer: :html, method: :smooth, type: :string }) do |value, _user_proc|
+  # alert :ici
+  format_params = case value
+                  when Array
+                    data_collected = []
+                    value.each do |param|
+                      data_collected << "#{param}px"
+                    end
+                    data_collected.join(' ')
+                  when Integer
+                    "#{value}px"
+                  else
+                    if value.is_a?(String) && value.end_with?('%')
+                      value
+                    else
+                      "#{value}px"
+                    end
+                  end
+  html.style('border-radius', format_params)
+end
+
+new({ renderer: :html, method: :blur, type: :integer }) do |value, _user_proc|
+  html.filter(:blur, "#{value}px")
+end

data/lib/renderers/html/event.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+new({ method: :drag, type: :symbol, renderer: :html }) do |params|
+  option = @drag[params]
+  html.event(:drag, params, option)
+end
+
+new({ method: :drop, type: :symbol, renderer: :html }) do |params|
+  option = @drop[params]
+  html.event(:drop, params, option)
+end
+
+new({ method: :touch, type: :integer, renderer: :html }) do |params|
+  option = @touch[params]
+  html.event(:touch, params, option)
+end
+
+new({ method: :over, type: :integer, renderer: :html }) do |params|
+  option = @over[params]
+  html.event(:over, params, option)
+end
+
+new({ method: :keyboard, renderer: :html }) do |params|
+  option = @keyboard[params]
+  html.event(:keyboard, params, option)
+end
+
+new({ method: :play, renderer: :html }) do |params = true|
+  option = @play[params]
+  # html.currentTime(params, option) if params != true
+  html.action(:play, params, option)
+  # params
+end
+
+new({ method: :on, renderer: :html }) do |params|
+  option = @on[params]
+  html.on(params, option)
+end
+
+new({ method: :resize, renderer: :html }) do |params, user_bloc|
+  option = @resize[params]
+  html.resize(params, option)
+end