atome 0.1.00009 → 0.4.7.0

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

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+# TODO: parent are not set correctly if not explicitly specified when attaching a child ex: b=box();c=b.box, c is not
+# attached to b
+# Genesis helper
+module GenesisHelper
+  def broadcaster(property, value)
+    "broadcast : #{property} #{value}"
+  end
+
+  def history(property, value)
+    "historize : #{property} #{value}"
+  end
+end
+
+# genesis kernel
+module GenesisKernel
+  # particle's methods
+  def set_new_particle(particle, value, &proc)
+    return false unless validation(particle)
+    # 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 })
+    # render option below
+    Genesis.run_optional_methods_helper("#{particle}_render_proc".to_sym,
+                                        { method: particle, value: value, atome: self, proc: proc })
+    # now we exec post render optional proc
+    value = Genesis.run_optional_methods_helper("#{particle}_post_render_proc".to_sym,
+                                                { 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_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, &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)
+    end
+  end
+
+  # atome's methods
+
+  def get_new_atome(atome)
+    return false unless validation(atome)
+
+    atome_instance_variable = "@#{atome}"
+    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, 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, 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
+      instance_variable_get(atome_instance_variable).additional(params)
+    else
+      instance_variable_get(atome_instance_variable).additional
+    end
+  end
+end
+
+# main entry for genesis
+module Genesis
+  include GenesisHelper
+  include GenesisKernel
+
+  # include ParticleGenesis
+  @optionals_methods = {}
+
+  def self.atome_creator_option(property_name, &proc)
+    @optionals_methods[property_name] = proc
+  end
+
+  def self.run_optional_methods_helper(method_name, params, atome = nil)
+
+    proc = nil
+    proc = @optionals_methods[method_name] if @optionals_methods
+    # 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)
+
+
+  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|
+      params[:atome].instance_exec(value, atome, user_proc, &methods_proc) if methods_proc.is_a?(Proc)
+    end
+  end
+
+  def self.generate_server_renderer(method_name, &methods_proc)
+    current_renderer = :headless
+    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)
+    end
+  end
+
+  # rendering methods are generated below:
+  def self.generate_renderers_methods(method_name)
+    # now we auto generate all rendering methods
+    Utilities.renderer_list.each do |render_method|
+      define_singleton_method("generate_#{render_method}_renderer") do |method_name, &methods_proc|
+        current_renderer = render_method
+        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)
+        end
+      end
+
+      send("generate_#{render_method}_renderer", method_name)
+    end
+
+    Genesis.atome_creator_option("#{method_name}_post_render_proc".to_sym) do |params|
+      # we return the value
+      params[:value]
+    end
+  end
+
+  def self.optional_atome_methods(method_name)
+    Genesis.atome_creator_option("#{method_name}_pre_save_proc".to_sym) do |params, proc|
+      # we return the value
+      params
+    end
+
+    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|
+      # we return the value
+      params[:value]
+    end
+
+  end
+
+  def self.additional_atome_methods(method_name)
+    # here is the pluralized
+    Atome.define_method "#{method_name}s" do |params = nil|
+      additional_atomes(method_name, params)
+    end
+    # here is the fast methods
+    Atome.define_method "set_#{method_name}" do |params = nil, &proc|
+      set_new_atome(method_name, params, proc)
+    end
+    Atome.define_method "get_#{method_name}" do
+      get_new_atome(method_name)
+    end
+    generate_renderers_methods(method_name)
+  end
+
+  # we create the easy methods here : ¬
+  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, &method_proc)
+    end
+    # no we also add the method= for easy setting
+    Atome.define_method("#{method_name}=") do |params, &user_proc|
+      new_atome(method_name, params, user_proc)
+    end
+    optional_atome_methods(method_name)
+    additional_atome_methods(method_name)
+  end
+
+  def self.optional_particle_methods(method_name)
+    # The rendering occur here setting up the optional rendering  by default
+    Genesis.atome_creator_option("#{method_name}_render_proc".to_sym) do |params|
+      params[:atome].render_engine(params[:method], params[:value], params[:atome], &params[:proc])
+      # we return the value
+      params[:value]
+    end
+    Genesis.atome_creator_option("#{method_name}_pre_render_proc".to_sym) do |params|
+      particle_instance_variable = "@#{params[:method]}"
+      params[:atome].instance_variable_set(particle_instance_variable, params[:value])
+      # we return the value
+      params[:value]
+    end
+    Genesis.atome_creator_option("#{method_name}_post_render_proc".to_sym) do |params|
+      # we return the value
+      params[:value]
+    end
+    Genesis.atome_creator_option("#{method_name}_getter_pre_proc".to_sym) do |params|
+      # we return the value
+      params[:value]
+    end
+
+  end
+
+  def self.additional_particle_methods(method_name)
+    # here is the fast methods
+    Atome.define_method "set_#{method_name}" do |params, &proc|
+      set_new_particle(method_name, params, &proc)
+    end
+
+    Atome.define_method "get_#{method_name}" do
+      get_new_particle(method_name)
+    end
+    # now we generate all basic default rendering methods
+    generate_renderers_methods(method_name)
+    # now we generate all optional methods
+    optional_particle_methods(method_name)
+  end
+
+  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, &method_proc)
+    end
+    # no we also add the method= for easy setting
+    Atome.define_method("#{method_name}=") do |params, &user_proc|
+      new_particle(method_name, params, user_proc)
+    end
+    additional_particle_methods(method_name)
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# use to sanitize and secure user input
+module Sanitizer
+  @default_params = {
+    render: [:html],
+    color: { x: 0, y: 0, z: 0, red: 0.6, green: 0.6, blue: 0.6, alpha: 1, diffusion: :linear },
+    box: { width: 100, height: 100, x: 100, y: 100,
+           color: { x: 0, y: 0, z: 0, red: 0.9, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
+           generator: :box, preset: :box },
+    shape: { width: 100, height: 100, x: 100, y: 100,
+             color: { x: 0, y: 0, z: 0, red: 0.1, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
+             generator: :manual },
+    drm: { type: :drm },
+    shadow: {}
+  }
+
+  def self.default_params
+    @default_params
+  end
+
+  def validation(atome_instance_var)
+    # TODO: write validation scheme
+    true if atome_instance_var
+  end
+
+  def sanitizer(params)
+    # TODO: write sanitizer scheme
+    # we reorder id and place it a the beginning of the hash before render
+    # id_found = params.delete(:id)
+    # params = { id: id_found }.merge(params)
+
+    # we reorder render and place it a the beginning of the hash
+    # render_found = params.delete(:render)
+    # { render: render_found }.merge(params)
+    params
+  end
+
+  def add_essential_drm(params)
+    essential_drm = { authorisation: { read: [Atome.current_user], write: [Atome.current_user] },
+                      atome: { read: [:all], write: [:me] } }
+    params[:drm] = if params[:drm]
+                     essential_drm.merge(params[:drm])
+                   else
+                     essential_drm
+                   end
+  end
+
+  def check_parent(params)
+    parent = [id]|| [:user_view]
+    params[:parent] = parent unless params[:parent]
+    params
+  end
+
+  def add_missing_id(atome_type, params)
+    type = params[:type] || atome_type
+    "#{type}_#{Universe.atomes.length}"
+  end
+
+  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
+      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]
+      # forcing default render can causes problems and crashes
+      # render= Sanitizer.default_params[:render]
+      params[:render] = render unless params[:render]
+      check_parent(params)
+
+  end
+end

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

@@ -0,0 +1,55 @@
+# 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 = {}, &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,
+                     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},&bloc )
+    new_atome.shape
+  end
+
+  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
+    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,
+                     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 },&bloc)
+    new_atome.shape
+  end
+
+end
+
+def box(params = {}, &proc)
+  Utilities.grab(:view).box(params,&proc)
+end
+
+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 drag(params = {}, &bloc)
+  Utilities.grab(:view).drag(params, &bloc)
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'geocoder'
+
+# add on for the atome method
+class Atome
+  def geolocation
+    # native version
+    public_ip = `curl https://api.ipify.org`
+    results = Geocoder.search(public_ip)
+    results.first.coordinates
+  end
+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/kernel/helpers/sha.rb

@@ -0,0 +1,6 @@
+class Atome
+  def calculate_sha(string)
+    Digest::SHA256.hexdigest(string)
+  end
+end
+

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Utilities
+module Utilities
+  @atome_list = []
+  @particle_list = []
+  @renderer_list = [:html, :headless, :server]
+
+
+  def self.renderer_list(atome = nil)
+    @renderer_list
+  end
+  def self.atome_list(atome = nil)
+    # this method is used to hold all available type of atomes
+    if atome
+      instance_variable_get('@atome_list').push(atome)
+    else
+      instance_variable_get('@atome_list')
+    end
+  end
+
+  #
+  def self.particle_list(particle = nil)
+    # this method is used to hold all available type of particles
+    if particle
+      instance_variable_get('@particle_list').push(particle)
+    else
+      instance_variable_get('@particle_list')
+    end
+  end
+
+  def self.grab(params)
+    Universe.atomes[params]
+  end
+
+
+
+
+end