atome 0.4.5.4 → 0.5.1.1

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

@@ -1,387 +0,0 @@
-# frozen_string_literal: true
-
-# generators
-
-Genesis.particle_creator(:html_type)
-Genesis.particle_creator(:html_object)
-
-
-Genesis.atome_creator(:shape)
-
-Genesis.atome_creator(:shadow)
-# Genesis.atome_creator(:additional)
-Genesis.atome_creator(:content)
-
-Genesis.atome_creator(:color)
-
-Genesis.atome_creator_option(:color_sanitizer_proc) do |params, atome|
-  unless params.instance_of? Hash
-    if RUBY_ENGINE.downcase == 'opal'
-      rgb_color = `d = document.createElement("div");
-	d.style.color = #{params};
-	document.body.appendChild(d)
-   rgb_color=(window.getComputedStyle(d).color);
-d.remove();
-`
-      color_converted = { red: 0, green: 0, blue: 0, alpha: 1 }
-      rgb_color.gsub("rgb(", "").gsub(")", "").split(",").each_with_index do |component, index|
-        color_converted[color_converted.keys[index]] = component.to_i / 255
-      end
-    else
-      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
-    end
-    params = { render: [:html], id: "color_#{atome.id}", type: :color }.merge(color_converted)
-  end
-  params
-end
-
-Genesis.atome_creator(:shadow)
-
-# Example below
-
-# Genesis.atome_creator(:color) do |params|
-#   # puts "extra color code executed!! : #{params}"
-# end
-# Genesis.atome_creator_option(:color_pre_save_proc) do |params|
-#   puts "1- optional color_pre_save_proc: #{params}\n"
-# end
-#
-# Genesis.atome_creator_option(:color_post_save_proc) do |params|
-#   puts "2- optional color_post_save_proc: #{params}\n"
-# end
-# #
-# Genesis.atome_creator_option(:left_pre_render_proc) do
-#   puts "3 - optional color_pre_render_proc\n"
-# end
-# Genesis.atome_creator_option(:left_post_render_proc) do
-#   puts "4 - optional color_post_render_proc\n"
-# end
-#
-# Genesis.atome_creator_option(:color_post_render_proc) do
-#   # puts "optional color_post_render_proc\n"
-# end
-#
-# Genesis.atome_creator_option(:color_getter_pre_proc) do
-#   # puts "optional color_getter_pre_proc\n"
-# end
-
-Genesis.particle_creator(:id) do
-end
-Genesis.particle_creator(:left)
-Genesis.particle_creator(:right)
-Genesis.particle_creator(:top)
-Genesis.particle_creator(:bottom)
-Genesis.particle_creator(:width)
-Genesis.particle_creator(:height)
-Genesis.particle_creator(:red)
-Genesis.particle_creator(:green)
-Genesis.particle_creator(:blue)
-Genesis.particle_creator(:alpha)
-Genesis.particle_creator(:type)
-Genesis.particle_creator(:smooth)
-Genesis.particle_creator(:blur)
-Genesis.particle_creator(:touch)
-# Genesis.atome_creator_option(:type_pre_render_proc) do |params|
-#   # alert "it works and get #{params}"
-#   params[:value]
-# end
-
-# important exemple below how to prevent rendering
-# Genesis.atome_creator_option(:top_render_proc) do |params|
-#   puts "====---> Hurrey no rendering :  #{params}"
-# end
-
-Genesis.particle_creator(:render)
-Genesis.particle_creator(:drm)
-Genesis.particle_creator(:parent)
-
-Genesis.atome_creator_option(:parent_pre_render_proc) do |params|
-  unless params[:value].instance_of? Array
-    params[:value] = [params[:value]]
-  end
-  params[:value]
-end
-Genesis.particle_creator(:date)
-Genesis.particle_creator(:location)
-
-# generate renderers
-
-Genesis.generate_html_renderer(:type) do |value, atome, proc|
-  send("#{value}_html", value, atome, proc)
-end
-
-Genesis.generate_html_renderer(:shape) do |value, atome, proc|
-  id_found = id
-  instance_exec(&proc) if proc.is_a?(Proc)
-  DOM do
-    div(id: id_found).atome
-  end.append_to($document[:user_view])
-  @html_object = $document[id_found]
-  @html_type = :div
-end
-
-Genesis.generate_html_renderer(:color) do |value, atome, proc|
-  instance_exec(&proc) if proc.is_a?(Proc)
-  @html_type = :style
-  $document.head << DOM("<style atome='#{type}' id='#{id}'></style>")
-end
-
-Genesis.generate_html_renderer(:red) do |value, atome, proc|
-  green_found = green
-  green_found ||= 0
-  blue_found = blue
-  blue_found ||= 0
-  alpha_found = alpha
-  alpha_found ||= 0
-  $document[id].inner_html = "\n.#{id}{background-color: rgba(#{value * 255},#{green_found * 255},#{blue_found * 255},#{alpha_found})}\n"
-
-end
-Genesis.generate_html_renderer(:green) do |value, atome, proc|
-  red_found = red
-  red_found ||= 0
-  blue_found = blue
-  blue_found ||= 0
-  alpha_found = alpha
-  alpha_found ||= 0
-  $document[id].inner_html = "\n.#{id}{background-color: rgba(#{red_found * 255},#{value * 255},#{blue_found * 255},#{alpha_found})}\n"
-
-end
-
-Genesis.generate_html_renderer(:blue) do |value, atome, proc|
-  red_found = red
-  red_found ||= 0
-  green_found = green
-  green_found ||= 0
-  alpha_found = alpha
-  alpha_found ||= 0
-  $document[id].inner_html = "\n.#{id}{background-color: rgba(#{red_found * 255},#{green_found * 255},#{value * 255},#{alpha_found})}\n"
-
-end
-
-Genesis.generate_html_renderer(:alpha) do |value, atome, proc|
-  red_found = red
-  red_found ||= 0
-  green_found = green
-  green_found ||= 0
-  blue_found = blue
-  blue_found ||= 0
-  $document[id].inner_html = "\n.#{id}{background-color: rgba(#{red_found * 255},#{green_found * 255},#{blue_found * 255},#{value})}\n"
-end
-
-Genesis.generate_html_renderer(:drm) do |value, atome, proc|
-  # instance_exec(&proc) if proc.is_a?(Proc)
-end
-
-Genesis.generate_html_renderer(:parent) do |values, atome, proc|
-  instance_exec(&proc) if proc.is_a?(Proc)
-  values.each do |value|
-    if @html_type == :style
-      # we remove previous class if the are of the same type of the type
-      # ex if there's a color already assign we remove it to allow the new one to be visible
-      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)
-    else
-      @html_object.append_to($document[value])
-    end
-  end
-end
-Genesis.generate_html_renderer(:id) do |value, atome, proc|
-  # send("#{value}_html", value, atome, proc)
-end
-
-Genesis.generate_html_renderer(:left) do |value, atome, proc|
-  @html_object.style[:left] = "#{value}px" unless @html_type == :style
-end
-
-Genesis.generate_html_renderer(:right) do |value, atome, proc|
-  @html_object.style[:right] = "#{value}px" unless @html_type == :style
-end
-
-Genesis.generate_html_renderer(:top) do |value, atome, proc|
-  @html_object.style[:top] = "#{value}px" unless @html_type == :style
-end
-
-Genesis.generate_html_renderer(:bottom) do |value, atome, proc|
-  @html_object.style[:bottom] = "#{value}px" unless @html_type == :style
-end
-
-Genesis.generate_html_renderer(:width) do |value, atome, proc|
-  @html_object.style[:width] = "#{value}px" unless @html_type == :style
-end
-
-Genesis.generate_html_renderer(:height) do |value, atome, proc|
-  @html_object.style[:height] = "#{value}px" unless @html_type == :style
-end
-
-Genesis.particle_creator(:rotate) do |params, atome, &proc|
-  # puts atome
-  # alert :pl
-  instance_exec(method_name, params, atome, &proc) if proc.is_a?(Proc)
-end
-Genesis.generate_html_renderer(:rotate) do |value, atome, proc|
-  @html_object.style[:transform] = "rotate(#{value}deg)" unless @html_type == :style
-end
-
-Genesis.generate_html_renderer(:smooth) do |value, atome, proc|
-  formated_params = case value
-                    when Array
-                      properties = []
-                      value.each do |param|
-                        properties << "#{param}px"
-                      end
-                      properties.join(' ').to_s
-                    when Integer
-                      "#{value}px"
-                    else
-                      value
-                    end
-  @html_object.style['border-radius'] = formated_params unless @html_type == :style
-end
-
-Genesis.generate_html_renderer(:touch) do |value, atome, proc|
-  @html_object.on :click do |e|
-    instance_exec(&proc) if proc.is_a?(Proc)
-  end
-end
-
-#drag
-def dragCallback(page_x, page_y, x, y, current_object, proc)
-  current_object.instance_variable_set('@left', x)
-  current_object.instance_variable_set('@top', y)
-  instance_exec(page_x, page_y, &proc) if proc.is_a?(Proc)
-end
-
-Genesis.particle_creator(:drag)
-
-Genesis.generate_headless_renderer(:drag) do |value, atome, user_proc|
-  puts "msg from headless drag method: value is #{value} , atome class is #{atome.class}"
-  instance_exec(&user_proc) if user_proc.is_a?(Proc)
-end
-
-Genesis.generate_html_renderer(:drag) do |value, atome, user_proc|
-  # FIXME: we should find a s solution to pass the proc to the dragCallback toavoid the test below
-  @html_drag = user_proc if user_proc
-  if value == :remove
-    @html_object.remove_class(:draggable)
-  else
-    @html_object.add_class(:draggable)
-  end
-end
-
-Genesis.particle_creator(:overflow)
-Genesis.generate_html_renderer(:overflow) do |value, atome, proc|
-  @html_object.style[:overflow] = value unless @html_type == :style
-end
-
-Genesis.particle_creator(:bloc)
-
-# image
-
-Genesis.atome_creator(:image)
-Genesis.particle_creator(:path)
-Genesis.generate_html_renderer(:path) do |value, atome, proc|
-  @html_object[:src] = value
-end
-Genesis.generate_html_renderer(:image) do |value, atome, proc|
-  id_found = id
-  instance_exec(&proc) if proc.is_a?(Proc)
-  DOM do
-    img({ id: id_found }).atome
-  end.append_to($document[:user_view])
-  @html_object = $document[id_found]
-  @html_type = :image
-end
-
-# text
-
-Genesis.atome_creator(:text)
-Genesis.particle_creator(:string)
-
-Genesis.generate_html_renderer(:string) do |value, atome, proc|
-  @html_object.text = value
-end
-Genesis.particle_creator(:visual)
-Genesis.generate_html_renderer(:visual) do |value, atome, proc|
-  @html_object.style['font-size'] = "#{value[:size]}px"
-end
-Genesis.generate_html_renderer(:text) do |value, atome, proc|
-  id_found = id
-  instance_exec(&proc) if proc.is_a?(Proc)
-  DOM do
-    div(id: id_found).atome
-  end.append_to($document[:user_view])
-  @html_object = $document[id_found]
-  @html_type = :text
-end
-
-
-# video
-Genesis.atome_creator(:video)
-Genesis.generate_html_renderer(:video) do |value, atome, proc|
-  id_found = id
-  instance_exec(&proc) if proc.is_a?(Proc)
-  DOM do
-    video({ id: id_found, autoplay: true }).atome
-  end.append_to($document[:user_view])
-  @html_object = $document[id_found]
-  @html_type = :video
-end
-
-
-# particles method below to allow to retrieve all particles for an atome
-Genesis.particle_creator(:particles)
-Genesis.atome_creator_option(:particles_getter_pre_proc) do |params|
-  atome_found = params[:atome]
-  particles_hash = {}
-  atome_found.instance_variables.each do |particle_found|
-    particle_content = atome_found.instance_variable_get(particle_found)
-    particles_hash[particle_found] = particle_content
-  end
-  particles_hash
-end
-
-
-# link
-Genesis.particle_creator(:link)
-Genesis.atome_creator_option(:link_pre_render_proc) do |params|
-  atome_found = params[:atome]
-  atome_to_link = grab(params[:value])
-  particles_found = atome_to_link.particles
-  atome_type = particles_found.delete('@type')
-  sanitized_particles = {}
-  particles_found.each do |particle_name, value|
-    particle_name = particle_name.gsub('@', '')
-    sanitized_particles[particle_name] = value
-  end
-  sanitized_particles[:parent]=[atome_found.id]
-  atome_found.send(atome_type, sanitized_particles)
-  params[:value]
-end
-Genesis.atome_creator(:web)
-Genesis.particle_creator(:path)
-Genesis.generate_html_renderer(:path) do |value, atome, proc|
-  @html_object[:src] = value
-end
-Genesis.generate_html_renderer(:web) do |value, atome, proc|
-  id_found = id
-  instance_exec(&proc) if proc.is_a?(Proc)
-  DOM do
-    iframe({ id: id_found }).atome
-  end.append_to($document[:user_view])
-  @html_object = $document[id_found]
-  @html_object.attributes[:allow]='accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture'
-  @html_object.attributes[:allowfullscreen]=true
-  @html_type = :web
-end
-

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

@@ -1,265 +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)
-
-    # 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 })
-    # 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_getted=instance_variable_get(particle_instance_variable)
-    Genesis.run_optional_methods_helper("#{particle}_getter_pre_proc".to_sym, { value: value_getted, atome: self })
-  end
-
-  def new_particle(particle, params, proc)
-    if params
-      set_new_particle(particle, params, &proc)
-    else
-      get_new_particle(particle)
-    end
-  end
-
-  # 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 })
-
-  end
-
-  def new_atome(atome, params, proc)
-    if params
-      params = add_essential_properties(atome, params)
-      params = sanitizer(params)
-      set_new_atome(atome, params, proc)
-    else
-      get_new_atome(atome)
-    end
-  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
-    instance_exec(params,atome, &proc) if proc.is_a?(Proc)
-  end
-
-  # #fIXME : we may have to remove the 2 methods below its only for test
-
-  # render methods generator
-  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)
-    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, &proc)
-    instance_exec(method_name, &proc) if proc.is_a?(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)
-    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, &proc)
-    instance_exec(method_name, &proc) if proc.is_a?(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)
-    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