atome 0.1.00009 → 0.4.5.4

data/lib/atome/kernel/atome.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# TODO: Id generator
+# Add missing params (methods for noobs only?)
+# Sanitizer (methods for noobs only?)
+# Sort params (methods for noobs only?)
+# Pre-processor
+# Renderer
+# Store
+# Post-processor
+# Add or set
+# Getter
+# parental
+# modify html file to be able to add meta data
+
+# This is the main entry for Atome class
+class Atome
+  include Genesis
+  include Sanitizer
+  include ServerRenderer
+  include Render
+  # include OpalRenderer
+  # include HeadlessRenderer
+  def self.atome(params)
+    Atome.new(params)
+  end
+
+  def self.current_machine_decision(platform, output)
+    case platform
+    when /darwin/
+      ::Regexp.last_match(1) if output =~ /en1.*?(([A-F0-9]{2}:){5}[A-F0-9]{2})/im
+    when /win32/
+      ::Regexp.last_match(1) if output =~ /Physical Address.*?(([A-F0-9]{2}-){5}[A-F0-9]{2})/im
+    else
+      # Cases for other platforms...
+      'unknown platform'
+    end
+    platform
+  end
+
+  def self.current_machine
+    platform = RUBY_PLATFORM.downcase
+    output = `#{platform =~ /win32/ ? 'ipconfig /all' : 'ifconfig'}`
+    current_machine_decision(platform, output)
+    # TODO: check the code above and create a sensible identity
+  end
+
+  def self.current_user
+    @user
+  end
+
+  def self.current_user=(user)
+    # TODO: create or load an existing user
+    # if user needs to be create the current_user will be eVe
+    @user = user
+  end
+
+  def identity_generator
+    { date: Time.now, location: geolocation }
+  end
+
+  def additional_helper(params)
+    virtual_atome = Atome.new({})
+    @additional = virtual_atome
+    params.each_with_index do |additional, index|
+      new_atome = Atome.new({})
+      virtual_atome.instance_variable_set("@virtual#{index}", new_atome)
+      additional.each do |param, value|
+        new_atome.send(param, value)
+      end
+    end
+  end
+
+  def additional(params = nil)
+    if params
+      additional_helper(params)
+    else
+      @additional
+    end
+  end
+
+  def initialize(params = {}, &proc)
+    # We initialize the renderer here
+    @render=[]
+    # # TODO: check if we need to add properties for the root object before sending the params
+    params.each do |atome, values|
+      # We add the proc if it exist
+      values[:bloc] = { bloc: proc }
+      send(atome, values)
+    end
+    Universe.atomes_add(self)
+  end
+end
+
+# initialize Universe
+Universe.connected
+# Atome.new( identity: {type: :eVe, aui: :a_97987987987})
+puts "atome version : #{Atome::VERSION}"

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

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