atome 0.4.7.0 → 0.5.1.1

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

@@ -1,277 +0,0 @@
-# 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

@@ -1,73 +0,0 @@
-# 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

@@ -1,55 +0,0 @@
-# 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/internal_methods.rb

@@ -1,173 +0,0 @@
-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/utilities.rb

@@ -1,39 +0,0 @@
-# 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

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

@@ -1,77 +0,0 @@
-class Atome
-
-  def identity (params)
-    @identity=params
-  end
-  def new(params)
-    puts "add/new : #{params}"
-  end
-
-  def set(params)
-    puts "set : #{params}"
-  end
-
-  def self.grab(val)
-    Utilities.grab(val)
-  end
-
-  def add(params)
-    puts "add : #{params}"
-  end
-
-  def update(params)
-    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)
-    self.html_object&.remove
-    Universe.delete(id)
-  end
-
-  def [](params)
-    instance_variable_get(instance_variables[params])
-  end
-
-  def to_s
-    inspect.to_s
-  end
-
-end
-