atome 0.4.5.4 → 0.4.7.0

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

@@ -17,8 +17,6 @@ module GenesisKernel
   # particle's methods
   def set_new_particle(particle, value, &proc)
     return false unless validation(particle)
-
-    # instance_exec({ options: value }, &proc) if proc.is_a?(Proc)
     # now we exec the first optional method
     value = Genesis.run_optional_methods_helper("#{particle}_pre_render_proc".to_sym,
                                                 { method: particle, value: value, atome: self, proc: proc })
@@ -30,18 +28,23 @@ module GenesisKernel
                                                 { method: particle, value: value, proc: proc })
     broadcaster(particle, value)
     history(particle, value)
+
     self
   end
 
   def get_new_particle(particle)
     return false unless validation(particle)
+
     particle_instance_variable = "@#{particle}"
-    value_getted=instance_variable_get(particle_instance_variable)
-    Genesis.run_optional_methods_helper("#{particle}_getter_pre_proc".to_sym, { value: value_getted, atome: self })
+    value_get = instance_variable_get(particle_instance_variable)
+    Genesis.run_optional_methods_helper("#{particle}_getter_pre_proc".to_sym, { value: value_get, atome: self })
   end
 
-  def new_particle(particle, params, proc)
+  def new_particle(particle, params, proc, &method_proc)
     if params
+      if method_proc.is_a?(Proc)
+        params = instance_exec(params, &method_proc)
+      end
       set_new_particle(particle, params, &proc)
     else
       get_new_particle(particle)
@@ -50,48 +53,53 @@ module GenesisKernel
 
   # atome's methods
 
-  def create_new_atomes(params, instance_var, _atome)
-    new_atome = Atome.new({})
-    instance_variable_set(instance_var, new_atome)
-    # FIXME : move this to sanitizer and ensure that no reorder happen for "id" and "render" when
-    params.each do |param, value|
-      new_atome.send(param, value)
-    end
-  end
-
-  def set_new_atome(atome, params, proc)
-    return false unless validation(atome)
-
-    instance_var = "@#{atome}"
-    # now we exec the first optional method
-    params=Genesis.run_optional_methods_helper("#{atome}_pre_save_proc".to_sym, { value: params, proc: proc })
-    create_new_atomes(params[:value], instance_var, atome)
-    # now we exec the second optional method
-    Genesis.run_optional_methods_helper("#{atome}_post_save_proc".to_sym, { value: params, proc: proc })
-    @dna = "#{Atome.current_user}_#{Universe.app_identity}_#{Universe.atomes.length}"
-    self
-  end
-
   def get_new_atome(atome)
     return false unless validation(atome)
 
-    # Genesis.run_optional_methods_helper("#{atome}_getter_pre_proc".to_sym, { value: false })
     atome_instance_variable = "@#{atome}"
-    value_getted=instance_variable_get(atome_instance_variable)
-    Genesis.run_optional_methods_helper("#{atome}_getter_pre_proc".to_sym, { value: value_getted })
+    value_get = instance_variable_get(atome_instance_variable)
+    Genesis.run_optional_methods_helper("#{atome}_getter_pre_proc".to_sym, { value: value_get })
 
   end
 
-  def new_atome(atome, params, proc)
+  def new_atome(atome, params, userproc, &method_proc)
     if params
+      # the line below execute the proc associated to the method, ex Genesis.atome_creator(:color) do ...(proc)
+      params = instance_exec(params, &method_proc) if method_proc.is_a?(Proc)
       params = add_essential_properties(atome, params)
       params = sanitizer(params)
-      set_new_atome(atome, params, proc)
+      set_new_atome(atome, params, userproc)
     else
       get_new_atome(atome)
     end
   end
 
+  def set_new_atome(atome, params, userproc)
+    params[:bloc] = userproc
+    return false unless validation(atome)
+
+    instance_var = "@#{atome}"
+    new_atome = Atome.new({}, &userproc)
+    # now we exec the first optional method
+    params = Genesis.run_optional_methods_helper("#{atome}_pre_save_proc".to_sym, { value: params, atome: new_atome, proc: userproc })
+    new_atome = create_new_atomes(params[:value], instance_var, new_atome, &userproc)
+    # now we exec the second optional method
+    Genesis.run_optional_methods_helper("#{atome}_post_save_proc".to_sym, { value: params, atome: new_atome, proc: userproc })
+    @dna = "#{Atome.current_user}_#{Universe.app_identity}_#{Universe.atomes.length}"
+    new_atome
+  end
+
+  def create_new_atomes(params, instance_var, new_atome, &userproc)
+    # new_atome = Atome.new({}, &userproc)
+    Universe.atomes_add(new_atome, params[:id])
+    instance_variable_set(instance_var, new_atome)
+    # FIXME : move this to sanitizer and ensure that no reorder happen for "id" and "render" when
+    params.each do |param, value|
+      new_atome.send(param, value)
+    end
+    new_atome
+  end
+
   def additional_atomes(atome, params)
     atome_instance_variable = "@#{atome}"
     if params
@@ -114,20 +122,25 @@ module Genesis
     @optionals_methods[property_name] = proc
   end
 
-  def self.run_optional_methods_helper(method_name, params, atome=nil)
+  def self.run_optional_methods_helper(method_name, params, atome = nil)
+
     proc = nil
     proc = @optionals_methods[method_name] if @optionals_methods
-    instance_exec(params,atome, &proc) if proc.is_a?(Proc)
-  end
+    # it run all methods that looks like :
+    # bloc_render_proc
+    # render_getter_pre_proc
+    # bloc_post_render_proc
+
+    params[:atome].instance_exec(params, atome, &proc) if proc.is_a?(Proc)
 
-  # #fIXME : we may have to remove the 2 methods below its only for test
 
-  # render methods generator
+  end
+
   def self.generate_html_renderer(method_name, &methods_proc)
     current_renderer = :html
     generated_method_name = "#{method_name}_#{current_renderer}".to_sym
     Atome.define_method generated_method_name do |value, atome, &user_proc|
-      instance_exec(value, atome, user_proc, &methods_proc) if methods_proc.is_a?(Proc)
+      params[:atome].instance_exec(value, atome, user_proc, &methods_proc) if methods_proc.is_a?(Proc)
     end
   end
 
@@ -166,12 +179,12 @@ module Genesis
       params
     end
 
-    Genesis.atome_creator_option("#{method_name}_sanitizer_proc".to_sym) do |params,atome, proc|
+    Genesis.atome_creator_option("#{method_name}_sanitizer_proc".to_sym) do |params, atome, proc|
       # we return the value
       params
     end
 
-    Genesis.atome_creator_option("#{method_name}_getter_pre_proc".to_sym) do |params,atome, proc|
+    Genesis.atome_creator_option("#{method_name}_getter_pre_proc".to_sym) do |params, atome, proc|
       # we return the value
       params[:value]
     end
@@ -194,13 +207,13 @@ module Genesis
   end
 
   # we create the easy methods here : ¬
-  def self.atome_creator(method_name, &proc)
-    instance_exec(method_name, &proc) if proc.is_a?(Proc)
+  def self.atome_creator(method_name, &method_proc)
+
     # we add the new method to the atome's collection of methods
     Utilities.atome_list(method_name)
     # we define many methods : easy, method=,pluralised and the fasts one, here is the easy
     Atome.define_method method_name do |params = nil, &user_proc|
-      new_atome(method_name, params, user_proc)
+      new_atome(method_name, params, user_proc, &method_proc)
     end
     # no we also add the method= for easy setting
     Atome.define_method("#{method_name}=") do |params, &user_proc|
@@ -249,12 +262,11 @@ module Genesis
     optional_particle_methods(method_name)
   end
 
-  def self.particle_creator(method_name, &proc)
-    instance_exec(method_name, &proc) if proc.is_a?(Proc)
+  def self.particle_creator(method_name, &method_proc)
     # we add the new method to the particle's collection of methods
     Utilities.particle_list(method_name)
     Atome.define_method method_name do |params = nil, &user_proc|
-      new_particle(method_name, params, user_proc)
+      new_particle(method_name, params, user_proc, &method_proc)
     end
     # no we also add the method= for easy setting
     Atome.define_method("#{method_name}=") do |params, &user_proc|

data/lib/atome/kernel/generators/sanitizer.rb

@@ -60,18 +60,14 @@ module Sanitizer
   def add_essential_properties(atome_type, params)
     # params_to_sanitize={atome: self, params: params}
     params=Genesis.run_optional_methods_helper("#{atome_type}_sanitizer_proc".to_sym, params, self)
-    # TODO remove the condition below once the line above works
-    # if params.instance_of? Hash
+      # TODO remove the condition below once the line above works
       params[:id] = add_missing_id(atome_type, params) unless params[:id]
       # FIXME : inject this in async mode to avoid big lag!
       params[:drm] = add_essential_drm(params) unless params[:drm]
-
-      render= Sanitizer.default_params[:render]
+      # forcing default render can causes problems and crashes
+      # render= Sanitizer.default_params[:render]
       params[:render] = render unless params[:render]
       check_parent(params)
-    # else
-    #   params
-    # end
 
   end
 end

data/lib/atome/kernel/generators/shapes.rb

@@ -1,22 +1,23 @@
 # frozen_string_literal: true
 # TODO: params shouldn't be merge but they must respect the order
-
+# TODO: Add default value for each methods below
+# TODO: Factorise codes below
 class Atome
-  def box(params = {})
+  def box(params = {}, &bloc)
     default_renderer = Sanitizer.default_params[:render]
     generated_id = params[:id] || "box_#{Universe.atomes.length}"
     generated_render = params[:render] || default_renderer unless params[:render].instance_of? Hash
     generated_parent = params[:parent] || id
 
-    temp_default = { render: [generated_render], id: generated_id, type: :shape, parent: [generated_parent], width: 99, height: 99, left: 9, top: 9,
+    temp_default = { render: [generated_render], id: generated_id,  type: :shape, parent: [generated_parent], width: 99, height: 99, left: 9, top: 9,
                      color: { render: [generated_render], id: "color_#{generated_id}", type: :color,
                               red: 0.69, green: 0.69, blue: 0.69, alpha: 1 } }
     params = temp_default.merge(params)
-    new_atome = Atome.new({ shape: params })
+    new_atome = Atome.new({ shape: params},&bloc )
     new_atome.shape
   end
 
-  def circle(params = {})
+  def circle(params = {}, &bloc)
     default_renderer = Sanitizer.default_params[:render]
     generated_id = params[:id] || "circle_#{Universe.atomes.length}"
     generated_render = params[:render] || default_renderer unless params[:render].instance_of? Hash
@@ -26,15 +27,29 @@ class Atome
                      color: { render: [generated_render], id: "color_#{generated_id}", type: :color,
                               red: 0.69, green: 0.69, blue: 0.69, alpha: 1 }, smooth: "100%" }
     params = temp_default.merge(params)
-    new_atome = Atome.new({ shape: params })
+    new_atome = Atome.new({ shape: params },&bloc)
     new_atome.shape
   end
+
+end
+
+def box(params = {}, &proc)
+  Utilities.grab(:view).box(params,&proc)
 end
 
-def box(params = {})
-  Utilities.grab(:view).box(params)
+def circle(params = {}, &proc)
+  Utilities.grab(:view).circle(params,&proc)
+end
+
+def text(params = {}, &bloc)
+  Utilities.grab(:view).text(params, &bloc)
+end
+
+
+def video(params = {}, &bloc)
+  Utilities.grab(:view).video(params, &bloc)
 end
 
-def circle(params = {})
-  Utilities.grab(:view).circle(params)
+def drag(params = {}, &bloc)
+  Utilities.grab(:view).drag(params, &bloc)
 end

data/lib/atome/kernel/helpers/internal_methods.rb

@@ -0,0 +1,173 @@
+module Internal
+  def self.read_ruby(file)
+    # TODO write a ruby script that'll list and sort all files so they can be read
+    `
+fetch('medias/rubies/'+#{file})
+  .then(response => response.text())
+  .then(text => Opal.eval(text))
+`
+  end
+
+  def self.read_text(file)
+    `
+fetch('medias/rubies/'+#{file})
+  .then(response => response.text())
+  .then(text => console.log(text))
+`
+  end
+
+  def text_data(value)
+    @html_object.text = value
+  end
+
+  def animator_data(value)
+    puts "send params to animation engine#{value}"
+  end
+
+  def _data(value)
+    #dummy method to handle atome with no type
+  end
+
+  def html_drag_helper(atome, options, parent = nil)
+    drag_id = atome.id
+    options[:max] = options[:max].to_n
+    `current_obj = Opal.Utilities.$grab(#{drag_id})`
+
+    `interact('.'+#{drag_id})
+            .draggable({
+                // enable inertial throwing
+               // startAxis: 'y',
+               // lockAxis: 'x',
+               lockAxis: #{options[:lock]},
+                inertia: true,
+                // keep the element within the area of it's parent
+                modifiers: [
+                    interact.modifiers.restrictRect({
+                        //restriction: 'parent',
+                        //restriction: { left: 333 ,right: 90, top: 333, bottom: 30},
+                        restriction: #{options[:max]},
+
+//elementRect: { left: , right: 0, top: 1, bottom: 1 }
+                        // endOnly: true,
+                    }),
+
+                ],
+                // enable autoScroll
+                autoScroll: true,
+
+                listeners: {
+                    // call this function on every dragmove event
+
+                    // move: dragMoveListener,
+                    move: dragMoveListener,
+                    // move(event){
+                    //     console.log('current atome is: '+self.current_obj)
+                    // },
+                    start(event) {
+                    bloc=#{atome.bloc}
+//TODO:  optimise this passing the proc to the drag callback
+                        // lets get the current atome Object
+                        // self.current_obj = Opal.Utilities.$grab(atome_drag_id)
+                        // now get the grab proc
+                        //self.proc_meth = current_obj.bloc
+                    },
+                    // call this function on every dragend event
+                    end(event) {
+
+                    }
+                }
+            })
+`
+
+    if options[:fixed]
+      `
+ function allow_drag(target,x,y){
+
+  }
+  `
+    else
+      `
+ function allow_drag(target,x,y){
+       target.style.transform = 'translate(' + x + 'px, ' + y + 'px)'
+    // update the position attributes
+    target.setAttribute('data-x', x)
+    target.setAttribute('data-y', y)
+  }
+  `
+    end
+
+    `
+function dragMoveListener(event) {
+    const target = event.target
+    // the code below can be conditioned to receive the drag event without moving the object
+    // keep the dragged position in the data-x/data-y attributes
+    const x = (parseFloat(target.getAttribute('data-x')) || 0) + event.dx;
+    const y = (parseFloat(target.getAttribute('data-y')) || 0) + event.dy
+    // translate the element
+      allow_drag(target,x,y)
+    // CallBack here
+    var object_dragged_id=Opal.Utilities.$grab(target.id)
+    #{atome}.$dragCallback(event.pageX, event.pageY, event.rect.left, event.rect.top, #{atome},object_dragged_id, bloc);
+}
+`
+  end
+
+  def drag_remove_true(current_atome)
+    current_atome.target.each do |value|
+      atome_found = grab(value)
+      # we get the id of the drag and ad add it as a html class to all children so they become draggable
+      # atome_found.html_object.remove_class(id)
+      atome_found.html_object.remove_class(current_atome.id)
+    end
+  end
+
+  def shape_remove_drag(atome)
+    class_to_remove = atome.drag.id
+    atome.html_object.remove_class(class_to_remove)
+  end
+
+  def dragCallback(page_x, page_y, x, y, current_object, object_dragged_id, proc = nil)
+    dragged_atome = grab(object_dragged_id.id)
+    dragged_atome.instance_variable_set('@left', x)
+    dragged_atome.instance_variable_set('@top', y)
+    current_object.instance_exec({ x: page_x, y: page_y }, &proc) if proc.is_a?(Proc)
+  end
+
+  def constraint_helper(params, current_atome, option)
+    options = {}
+    current_atome.particles.each do |particle, value|
+      options[particle] = value if (particle != :id && particle != :render && particle != :child && particle != :html_type && particle != :type && particle != :html_object && particle != :target)
+    end
+    options = options.merge({ option => params[:value] })
+    current_atome.target.each do |value|
+      atome_found = grab(value)
+      # we get the id of the drag and ad add it as a html class to all children so they become draggable
+      atome_found.html_object.remove_class(current_atome.id)
+      atome_found.html_object.add_class(current_atome.id)
+      html_drag_helper(current_atome, options)
+    end
+
+  end
+
+  def html_decision(html_type, value, id)
+    case html_type
+    when :style
+      # remove previous class if the are of the same type of the type, example:
+      # if there's a color already assign we remove it to allow the new one to be visible
+      # comment / uncomment below if we need to remove class or not
+      html_parent = grab(value).instance_variable_get("@html_object")
+      html_parent.class_names.each do |class_name|
+        if $document[class_name] && $document[class_name].attributes[:atome]
+          class_to_remove = $document[class_name].attributes[:id]
+          html_parent.remove_class(class_to_remove)
+        end
+      end
+      $document[value].add_class(id)
+    when :unset
+    else
+      @html_object.append_to($document[value])
+    end
+
+  end
+
+end

data/lib/atome/kernel/helpers/ping.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Atome
+  def ping(address, my_proc: false)
+    # if  RUBY_ENGINE.downcase != 'opal'
+    def up?(host, my_proc)
+      check = Net::Ping::External.new(host)
+      if check.ping?
+        puts "ping respond!! "
+      end
+    end
+
+    chost = address
+    puts up?(chost, my_proc) # prints "true" if ping replies
+    # end
+  end
+end

data/lib/atome/{extensions → kernel/helpers}/utilities.rb

@@ -30,10 +30,10 @@ module Utilities
   end
 
   def self.grab(params)
-    atome_found = nil
-    Universe.atomes.each do |atome|
-      atome_found = atome if atome.id == params
-    end
-    atome_found
+    Universe.atomes[params]
   end
+
+
+
+
 end

data/lib/atome/kernel/properties/essential.rb

@@ -23,12 +23,46 @@ class Atome
     puts "update : #{params}"
   end
 
+  def refresh
+    # delete the object in the view
+    self.html_object&.remove
+    particles_found = particles
+    particles_found.delete(:html_type)
+    particles_found.delete(:html_object)
+    particles_found.delete(:id)
+    particles_found.delete(:dna)
+    atomes_to_re_attach = {}
+    Utilities.atome_list.each do |atome_to_refresh|
+      atome_found = particles_found.delete(atome_to_refresh)
+      if atome_found
+        particles_found.delete(atome_to_refresh)
+        atomes_to_re_attach[atome_found.type] = atome_found
+      end
+    end
+    particles_found.each do |particle_to_refresh, value|
+      send(particle_to_refresh, value)
+    end
+    atomes_to_re_attach.each do |atome_to_attatch, content|
+      instance_variable_set("@#{atome_to_attatch}", content)
+      html_decision(content.html_type, id, content.id)
+    end
+  end
+
+
   def replace(params)
     puts "replace : #{params}"
   end
 
+  def clear
+    child.each do |child_found|
+      grab(child_found).html_object&.remove
+    end
+    child([])
+  end
+
   def delete(params)
-    puts "replace : #{params}"
+    self.html_object&.remove
+    Universe.delete(id)
   end
 
   def [](params)

data/lib/atome/kernel/sparkle.rb

@@ -9,11 +9,12 @@ default_render = if RUBY_ENGINE.downcase == 'opal'
                    :headless
                  end
 
+
 Sanitizer.default_params[:render] = default_render
 Atome.new(
   { shape: { render: [default_render], id: :view, type: :shape, parent: [:user_view],
              left: 0, right: 0, top: 0, bottom: 0,overflow: :auto,
-             color: { render: [default_render], id: :c1, type: :color,
+             color: { render: [default_render], id: :view_color, type: :color,
                       red: 0.15, green: 0.15, blue: 0.15, alpha: 1 } } }
 )
 

data/lib/atome/kernel/universe.rb

@@ -11,12 +11,20 @@ class Universe
   end
 
   def self.initialize
-    @atomes = []
+    @atomes = {}
   end
 
-  def self.atomes_add(new_atome)
-    # @atomes[atome_id] = new_atome
-    @atomes << new_atome
+  def self.atomes_add(new_atome,atome_id)
+    new_atome.instance_variable_set('@id', atome_id)
+    @atomes[atome_id] = new_atome
+  end
+
+  def self.change_atome_id(prev_id, new_id)
+    @atomes[new_id] = @atomes.delete(prev_id)
+  end
+
+  def self.delete(id)
+    @atomes.delete(id)
   end
 
   class << self

data/lib/atome/renderers/opal/extensions/geolocation.rb

@@ -5,7 +5,6 @@ class Atome
     $window.navigator.geolocate.then do |pos|
       localisation[:latitude] =  pos.coords.latitude
       localisation[:longitude] =  pos.coords.longitude
-      # alert self.inspect
     end.rescue do |err|
       p  err
       localisation = nil

data/lib/atome/renderers/renderer.rb

@@ -3,6 +3,7 @@
 # Main render engine
 module Render
   def render_engine(property, value, atome, &proc)
+
     renderer_found = atome.render
     renderer_found.each do |renderer|
       renderer_name = "#{property}_#{renderer}"

data/lib/atome/renderers/server/properties/generator.rb

@@ -2,7 +2,7 @@
 
 # server render methods here
 module ServerRenderer
-  def render_sever(params, &proc)
+  def render_server(params, &proc)
     instance_exec(params, &proc) if proc.is_a?(Proc)
     puts "----puts render sever render #{params}"
   end

data/lib/atome/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 class Atome
-  VERSION = '0.4.5.4'
+  VERSION = '0.4.7.0'
 end
+puts "atome version : #{Atome::VERSION}"

data/lib/atome.rb

@@ -18,7 +18,8 @@ end
 
 require 'atome/kernel/universe'
 require 'atome/kernel/generators/genesis'
-require 'atome/extensions/utilities'
+require 'atome/kernel/helpers/internal_methods'
+require 'atome/kernel/helpers/utilities'
 require 'atome/renderers/renderer'
 require 'atome/kernel/generators/sanitizer'
 require 'atome/kernel/generators/generator'
@@ -40,20 +41,10 @@ Atome.current_user = :jeezs
 require 'atome/kernel/sparkle'
 
 # TODO: create a system to secure and validate generated renderer methods , optional methods and atome's methods
-
-# test below uncomment when production mode
-# require '../test/test_app/application/index'
-# if RUBY_ENGINE.downcase != 'opal'
-#   rgb_color = Color::CSS["red"].css_rgb
-#   color_converted = { red: 0, green: 0, blue: 0, alpha: 1 }
-#   rgb_color.gsub("rgb(", "").gsub(")", "").gsub("%", "").split(",").each_with_index do |component, index|
-#     component = component.to_i/100
-#     color_converted[color_converted.keys[index]] = component
-#   end
-#   puts color_converted
-# end
-
-
+# TODO: int8! : language
+# TODO: record user actions
+# TODO: separate the audio in the video
+# TODO: add mute to video
 
 
 

data/vendor/assets/build/css/style.css

@@ -63,4 +63,8 @@ html, body {
     overflow: visible;
 }
 
+.text {
+    -webkit-text-fill-color: transparent;
+    -webkit-background-clip: text;
+}