atome 0.1.00009 → 0.4.5.4

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

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

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

@@ -0,0 +1,77 @@
+# 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
+    # if params.instance_of? Hash
+      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]
+      params[:render] = render unless params[:render]
+      check_parent(params)
+    # else
+    #   params
+    # end
+
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+# TODO: params shouldn't be merge but they must respect the order
+
+class Atome
+  def box(params = {})
+    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 })
+    new_atome.shape
+  end
+
+  def circle(params = {})
+    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 })
+    new_atome.shape
+  end
+end
+
+def box(params = {})
+  Utilities.grab(:view).box(params)
+end
+
+def circle(params = {})
+  Utilities.grab(:view).circle(params)
+end

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

@@ -0,0 +1,43 @@
+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 replace(params)
+    puts "replace : #{params}"
+  end
+
+  def delete(params)
+    puts "replace : #{params}"
+  end
+
+  def [](params)
+    instance_variable_get(instance_variables[params])
+  end
+
+  def to_s
+    inspect.to_s
+  end
+
+end
+

data/lib/atome/kernel/sparkle.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# FIXME : try avoid type property duplication (it's the key of the hash and also specified in the hash itself)
+
+# let's create the view port
+default_render = if RUBY_ENGINE.downcase == 'opal'
+                   :html
+                 else
+                   :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,
+                      red: 0.15, green: 0.15, blue: 0.15, alpha: 1 } } }
+)
+
+
+# init basic object for atome environment
+
+# Atome.new is used  to create a new atome using best performances but params must be formatted and ordered correctly
+
+# use atome.atome to create a new atome using a more permissive syntax less performances but params must be formatted
+# and ordered correctly
+
+# Atome.atome ids the easiest way to  create a new atome
+# Atome.atome({
+#                      shape: { left: 0, right: 0, top: 0, bottom: 0, id: :view, color: { id: :c1, render: [:headless],
+# red: 0.15, green: 0.15, blue: 0.15, alpha: 1 } } })
+
+# WARNING: when using Atome.new syntax , you must get your object using the .atome
+# example  to get the atome above : use a.shape.left and not a.left it wont access the physical object
+
+puts "current machine id: #{Atome.current_machine}"
+

data/lib/atome/kernel/universe.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# all created atomes are listed here
+class Universe
+  def self.app_identity
+    # each app hav its own identity, this allow to generate new user identities from th
+    @app_identity = 3
+    # the identity is define as follow : parentCreatorID_softwareInstanceID_objetID
+    # in this case parent is eve so 0, Software instance number is main eVe server which is also 0,
+    # and finally the object is 3 as this the third object created by the main server
+  end
+
+  def self.initialize
+    @atomes = []
+  end
+
+  def self.atomes_add(new_atome)
+    # @atomes[atome_id] = new_atome
+    @atomes << new_atome
+  end
+
+  class << self
+    attr_reader :atomes
+  end
+
+  def self.connected
+    true
+  end
+end

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

@@ -0,0 +1 @@
+# frozen_string_literal: true

data/lib/atome/renderers/opal/atome_opal_extensions.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'extensions/geolocation'
+require 'extensions/ping'
+require 'extensions/sha'
+require 'extensions/color'
+require 'properties/generator'

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# rgb utility
+class Atome
+  def rgb_html(string)
+    `
+  col = w3color(#{string});
+  rgb_col=col.toRgb();
+  return Opal.hash(rgb_col)
+ `
+  end
+
+  def to_rgb(string)
+    rgb_color = rgb_html(string)
+
+    {
+      red: rgb_color[:r] / 255,
+      green: rgb_color[:g] / 255,
+      blue: rgb_color[:b] / 255,
+      alpha: 1
+    }
+  end
+end

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

@@ -0,0 +1,14 @@
+
+class Atome
+  def geolocation
+    localisation = {latitude: nil, longitude: nil}
+    $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
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Add on the Atome class
+class Atome
+  def ping(my_proc = false)
+    instance_exec(my_proc) if my_proc.is_a?(Proc)
+
+    ` var p = new Ping();
+        p.ping('https://'+#{address}+'', function (err, data) {
+            if (err) {
+               return false;
+            } else {
+ console.log("the site "+#{address}+" is up!");
+            }
+        });
+`
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# addon for the Atome class
+class Atome
+  def calculate_sha(string)
+    if RUBY_ENGINE.downcase == 'opal'
+      `sha256(#{string})`
+    else
+      Digest::SHA256.hexdigest(string)
+    end
+  end
+end

data/lib/atome/renderers/opal/opal_browser.rb

@@ -4,4 +4,5 @@
 require 'opal'
 require 'native'
 require 'promise'
-require 'browser/setup/full'
+require 'browser/setup/full'
+@atome_client_ready = true

data/lib/atome/renderers/opal/opal_parser.rb

@@ -1,2 +1,3 @@
 # frozen_string_literal: true
+
 require 'opal-parser'

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

@@ -0,0 +1 @@
+# frozen_string_literal: true

data/lib/atome/renderers/renderer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# 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}"
+      send(renderer_name, value,atome, &proc)
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# server render methods here
+module ServerRenderer
+  def render_sever(params, &proc)
+    instance_exec(params, &proc) if proc.is_a?(Proc)
+    puts "----puts render sever render #{params}"
+  end
+end

data/lib/atome/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Atome
-  VERSION = '0.1.00009'
+  VERSION = '0.4.5.4'
 end

data/lib/atome.rb

@@ -2,5 +2,58 @@
 
 require 'fileutils'
 require 'atome/version'
-require 'atome/kernel/properties/geometry'
-require 'atome/kernel/atome_genesis'
+@atome_client_ready = false
+
+def eval_protection
+  binding
+end
+
+# FIXME: atome run doesnt run the code
+if RUBY_ENGINE.downcase != 'opal'
+  # FIXME: find a better and more elegant solution to avoid opal to treat require
+  # FIXME:  replace eval with a safer option
+  eval "require 'atome/atome_native_extensions'", eval_protection, __FILE__, __LINE__
+  eval "require 'color'", eval_protection, __FILE__, __LINE__
+end
+
+require 'atome/kernel/universe'
+require 'atome/kernel/generators/genesis'
+require 'atome/extensions/utilities'
+require 'atome/renderers/renderer'
+require 'atome/kernel/generators/sanitizer'
+require 'atome/kernel/generators/generator'
+require 'atome/renderers/opal/properties/generator'
+require 'atome/renderers/server/properties/generator'
+require 'atome/renderers/headless/properties/generator'
+require 'atome/kernel/generators/shapes'
+require 'atome/kernel/atome'
+require 'atome/kernel/properties/essential'
+require 'atome/extensions/helper'
+
+Universe.send(:initialize)
+# puts "@atome_client_ready is : #{@atome_client_ready}"
+
+# puts "app_identity is : #{Universe.app_identity}"
+
+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
+
+
+
+
+