atome 0.5.4.1.9 → 0.5.5.6.4

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.4'
+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

data/lib/renderers/html/geometry.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+new({ method: :width, type: :integer, renderer: :html }) do |value, _user_proc|
+  unit_found = unit[:width]
+  if unit_found
+    html.style(:width, "#{value}#{unit_found}")
+  elsif value.instance_of? Integer
+    html.style(:width, "#{value}px")
+  else
+    html.style(:width, value)
+  end
+end
+
+new({ method: :height, renderer: :html, type: :string }) do |value, _user_proc|
+  unit_found = unit[:height]
+  if unit_found
+    html.style(:height, "#{value}#{unit_found}")
+  elsif value.instance_of? Integer
+    html.style(:height, "#{value}px")
+  else
+    html.style(:height, value)
+  end
+end
+
+new({ method: :size, type: :hash, renderer: :html }) do |value, _user_proc|
+  # html.style('fontSize',"#{value}px")
+end
+
+new({ method: :size, type: :int, renderer: :html, specific: :text }) do |value, _user_proc|
+  html.style('fontSize', "#{value}px")
+end