atome 0.5.1.1 → 0.5.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62c07cd1f5c087a9dfe4e36b06cf4422e614657aa98cfee2e419f794e51f2eeb
-  data.tar.gz: b2d2eb46ba7599080b0f2d515a62659696375514579ce007721d8a012de15e18
+  metadata.gz: 64c8921a4ed715c0ed422e430ca3e9b6ead122f06e81032d0e8843b9fa2e0e4c
+  data.tar.gz: 7920b914b719630b1a930d1f27616d31161e8befe33fd409098a55a90cf30ced
 SHA512:
-  metadata.gz: ddd934acb39f162de762e634e3cc7f81cee597ccdba358cef0b294ace259b4766a9257c84704232447a85bf36cb4bbd331db9d486d979b5319ff4bdf6343c210
-  data.tar.gz: 38ce69c494f2b55e667329e72c2e87bf80ac1b8a8787cea5d3c378f7c46cd7814fbfd6b3ac868d428deeaa07b594cb64ac1482f23817122e3a236f8c7cc3bc2f
+  metadata.gz: 2d1fe5f8e8967e1869da808953904dbcd41327676bf644cf19b260cc56f0febdf38a3d3673056ab51406ca0b6743708dcf2c5b1d8fb6e20cd7f8f8b94d425ebd
+  data.tar.gz: 314bec01e683e3bcf0e57abfe1bc273bf38a91650da89f277449226b8f23dc7626c1d3d76e0d8408bdc7e82f5c337e8beb2fae3e73b23cd827102374d8b62c24

data/Rakefile

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rake/testtask"
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/test_*.rb"]
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/test_*.rb']
 end
 
 task default: :test

data/app_builder_helpers/Rakefile

@@ -107,6 +107,7 @@ def build_user_code(user_project_path, source_code)
   File.open(application_js, 'w') do |f|
     f.puts application_content
   end
+  # minimize_application(user_project_path)
 end
 
 def minimize_aui(user_project_path)
@@ -215,7 +216,6 @@ task :build_user_code, :user_project_path, :production do |_t, args|
   user_project_path = args[:user_project_path]
   source_code = "#{user_project_path}/application/index.rb"
   build_user_code(user_project_path, source_code)
-  minimize_application(user_project_path)
 end
 
 task :system_builder, :user_project_path, :production do |_t, args|

data/exe/atome

@@ -145,7 +145,7 @@ def test_native(build_target)
   when :windows
     # windows
   else
-    puts :freebsd
+    # freebsd
   end
 end
 

data/lib/atome/{atome_meta_engine.rb → atome.rb}

@@ -13,12 +13,14 @@ class Atome
 
   def initialize(atomes = {}, &atomes_proc)
     atomes.each_value do |elements|
+      # the instance variable below contain the id all any atomes that need to be informed when changes occurs
       @broadcast = {}
-      Universe.add_to_atomes({ elements[:id] => self })
-      elements[:bloc] = atomes_proc if atomes_proc
+      # now we store the proc in a an atome's property called :bloc
+      elements[:code] = atomes_proc if atomes_proc
       @atome = elements
-      # now we initiate the rendering eg for for browser will call :browser_type generated method in identity.rb file
-      type(@atome[:type])
+      # we initiate the rendering, eg for for browser we will call :browser_type generate method in identity.rb file
+      create_particle(:type, @atome[:type])
+      collapse
     end
   end
 
@@ -27,7 +29,8 @@ class Atome
       if params
         # the line below execute the proc created when using the build_particle method
         instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
-        sanitize_particle(element, params, &user_proc)
+        params = sanitize(element, params)
+        create_particle(element, params, &user_proc)
       else
         get_particle(element, &user_proc)
       end
@@ -37,7 +40,8 @@ class Atome
   def additional_particle_methods(element, &method_proc)
     Atome.define_method "#{element}=" do |params = nil, &user_proc|
       instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
-      sanitize_particle(element, params, &user_proc)
+      params = sanitize(element, params)
+      create_particle(element, params, &user_proc)
     end
   end
 
@@ -45,7 +49,7 @@ class Atome
     Atome.define_method element do |params = nil, &user_proc|
       if params
         instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
-        params = atome_sanitizer(element, params)
+        params = sanitize(element, params)
         Atome.new({ element => params })
       else
         get_atome(element, &user_proc)
@@ -59,14 +63,8 @@ class Atome
     end
   end
 
-  def new_atome_sanitizer(sanitizer_name)
-    Atome.define_method sanitizer_name do |params = {}|
-      params
-    end
-  end
-
   def run_optional_proc(proc_name, atome = self, value = '')
-    option_found = Universe.get_optionals_methods(proc_name)
+    option_found = Universe.get_optional_method(proc_name)
     atome.instance_exec(value, &option_found) if option_found.is_a?(Proc)
   end
 
@@ -93,11 +91,10 @@ class Atome
   def create_particle(element, value, &user_proc)
     return false unless security_pass(element, value)
 
-    run_optional_proc("pre_save_#{element}".to_sym, self, value)
-    store_value(element, value)
-    run_optional_proc("post_save_#{element}".to_sym, self, value)
+    run_optional_proc("pre_render_#{element}".to_sym, self, value)
     rendering(element, value, &user_proc)
     run_optional_proc("post_render_#{element}".to_sym, self, value)
+    store_value(element, value)
     self
   end
 

data/lib/atome/extensions/atome.rb

@@ -36,6 +36,6 @@ def shadow(params = {}, &bloc)
   grab(:view).shadow(params, &bloc)
 end
 
-def code(params = {}, &bloc)
-  grab(:view).code(params, &bloc)
+def web(params = {}, &bloc)
+  grab(:view).web(params, bloc)
 end

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

@@ -3,6 +3,23 @@
 generator = Genesis.generator
 
 generator.build_atome(:color)
+generator.build_sanitizer(:color) do |params|
+  parent_found = found_parents_and_renderers[:parent]
+  render_found = found_parents_and_renderers[:renderers]
+  default_params = { renderers: render_found, id: "color_#{Universe.atomes.length}", type: :color,
+                     parents: parent_found,
+                     red: 0, green: 0, blue: 0, alpha: 1 }
+  params = create_color_hash(params) unless params.instance_of? Hash
+  default_params.merge!(params)
+end
+
+generator.build_sanitizer(:video) do |params|
+  parent_found = found_parents_and_renderers[:parent]
+  render_found = found_parents_and_renderers[:renderers]
+  default_params = { renderers: render_found, id: "video_#{Universe.atomes.length}", type: :video,
+                     parents: parent_found }
+  default_params.merge!(params)
+end
 generator.build_atome(:shadow)
 generator.build_atome(:shape)
 generator.build_atome(:text)
@@ -11,3 +28,11 @@ generator.build_atome(:video)
 generator.build_atome(:code)
 generator.build_atome(:audio)
 generator.build_atome(:element)
+generator.build_atome(:web)
+generator.build_sanitizer(:element) do |params|
+  parent_found = found_parents_and_renderers[:parent]
+  render_found = []
+  default_params = { renderers: render_found, id: "element_#{Universe.atomes.length}", type: :element,
+                     parents: parent_found }
+  default_params.merge!(params)
+end

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

@@ -3,3 +3,8 @@
 generator = Genesis.generator
 
 generator.build_particle(:touch)
+generator.build_particle(:play)
+generator.build_particle(:time)
+generator.build_particle(:pause)
+generator.build_particle(:on)
+generator.build_particle(:fullscreen)

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

@@ -5,9 +5,23 @@ generator = Genesis.generator
 generator.build_particle(:type)
 generator.build_particle(:parents)
 generator.build_particle(:children)
+generator.build_particle(:link) do |child_id|
+  child_found = grab(child_id)
+  child_found.atome[:parents] << @atome[:id]
+  child_found.refresh
+end
+
 generator.build_particle(:id)
+generator.build_sanitizer(:id) do |params|
+  if @atome[:id] != params
+    Universe.update_atome_id(params, self, @atome[:id])
+  else
+    Universe.add_to_atomes(params, self)
+  end
+  params
+end
 
-generator.build_optional_methods(:pre_save_parents) do |parents_id_found|
+generator.build_option(:pre_render_parents) do |parents_id_found|
   parents_id_found.each do |parents_id|
     parents_found = grab(parents_id)
     parents_found.children << id if parents_found

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

@@ -9,4 +9,5 @@ end
 generator.build_particle(:right)
 generator.build_particle(:top)
 generator.build_particle(:bottom)
+generator.build_particle(:rotate)
 generator.build_particle(:direction)

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

@@ -3,7 +3,11 @@
 generator = Genesis.generator
 
 generator.build_particle(:renderers)
-generator.build_particle(:bloc)
+generator.build_particle(:code)
+generator.build_particle(:run) do |params|
+  code_found = @atome[:code]
+  instance_exec(params, &code_found) if code_found.is_a?(Proc)
+end
 generator.build_particle(:broadcast)
 generator.build_particle(:additional)
 generator.build_particle(:data)
@@ -12,3 +16,16 @@ generator.build_particle(:delete) do
 end
 generator.build_particle(:clear)
 generator.build_particle(:path)
+generator.build_particle(:schedule) do |date, proc|
+  date = date.to_s
+  delimiters = [',', ' ', ':', '-']
+  format_date = date.split(Regexp.union(delimiters))
+  Universe.renderer_list.each do |renderer|
+    send("#{renderer}_schedule", format_date, &proc)
+  end
+end
+generator.build_particle(:read) do |file, proc|
+  Universe.renderer_list.each do |renderer|
+    send("#{renderer}_reader", file, &proc)
+  end
+end

data/lib/atome/genesis/genesis.rb

@@ -23,13 +23,9 @@ class Atome
     # we add the new method to the atome's collection of methods
     Universe.add_to_atome_list(atome_name)
     auto_render_generator(atome_name)
-    auto_sanitizer_generator(atome_name)
     new_atome(atome_name, &atome_proc)
   end
 
-  def auto_sanitizer_generator(element)
-    build_sanitizer_method("sanitize_#{element}")
-  end
   def auto_render_generator(element)
     Universe.renderer_list.each do |render_engine|
       build_render_method("#{render_engine}_#{element}")
@@ -40,12 +36,11 @@ class Atome
     new_render_engine(renderer_name, &method_proc)
   end
 
-  def build_sanitizer_method(sanitizer_name)
-    new_atome_sanitizer(sanitizer_name)
+  def build_sanitizer(method_name, &method_proc)
+    Universe.add_sanitizer_method(method_name.to_sym, &method_proc)
   end
 
-
-  def build_optional_methods(method_name, &method_proc)
-    Universe.add_optionals_methods(method_name.to_sym, &method_proc)
+  def build_option(method_name, &method_proc)
+    Universe.add_optional_method(method_name.to_sym, &method_proc)
   end
 end

data/lib/atome/helpers/callbacks.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+#  callbacks methods here
+class Atome
+  def schedule_callback(proc)
+    instance_exec(&proc) if proc.is_a?(Proc)
+  end
+
+  def read_callback(file, proc)
+    instance_exec(file, &proc) if proc.is_a?(Proc)
+  end
+end

data/lib/atome/helpers/essentials.rb

@@ -6,13 +6,13 @@ module Essentials
     render_engines: [:browser],
     element: { type: :element, renderers: [] },
     box: { renderers: '', id: '', type: :shape, parents: [], children: [], width: 99, height: 99 },
-    circle: { renderers: '', id: '', type: :shape, parents: [], children: [], width: 99, height: 99, left: 12, top: 12,
+    circle: { renderers: '', id: '', type: :shape, parents: [], children: [], width: 99, height: 99,
               smooth: '100%' },
     shape: { renderers: '', id: '', width: 100, type: :shape, height: 100, left: 100, top: 100,
              color: { left: 0, top: 0, z: 0, red: 0.1, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
              generator: :manual },
     text: { type: :text, parents: [:view], children: [], visual: { size: 25 },
-            data: 'this is a text sample', left: 300, top: 33, width: 199, height: 33 },
+            data: 'this is a text sample',  width: 199, height: 33 },
     drm: { type: :drm },
     shadow: {}
   }

data/lib/atome/helpers/sanitizer.rb

@@ -10,7 +10,7 @@ class Atome
     { red: split_data[0].to_f / 100, green: split_data[1].to_f / 100, blue: split_data[2].to_f / 100 }
   end
 
-  def found_parent_and_render
+  def found_parents_and_renderers
     if @atome
       parent_found = [@atome[:id]]
       render_found = @atome[:renderers]
@@ -20,23 +20,4 @@ class Atome
     end
     { parent: parent_found, renderers: render_found }
   end
-
-  def sanitize_element(params)
-    parent_found = found_parent_and_render[:parent]
-    render_found = found_parent_and_render[:renderers]
-    default_params = { renderers: render_found, id: "element_#{Universe.atomes.length}", type: :element,
-                       parents: parent_found }
-    default_params.merge!(params)
-  end
-
-  def sanitize_color(params)
-    parent_found = found_parent_and_render[:parent]
-    render_found = found_parent_and_render[:renderers]
-    default_params = { renderers: render_found, id: "color_#{Universe.atomes.length}", type: :color,
-                       parents: parent_found,
-                       red: 0, green: 0, blue: 0, alpha: 1 }
-    params = create_color_hash(params) unless params.instance_of? Hash
-    default_params.merge!(params)
-  end
-
 end

data/lib/atome/helpers/utilities.rb

@@ -4,7 +4,7 @@
 class Atome
   private
 
-  def a_render
+  def collapse
     @atome.each do |element, value|
       send(element, value) unless element == :type
     end
@@ -14,19 +14,12 @@ class Atome
     true
   end
 
-  def particle_sanitizer(_element, params)
+  def sanitize(element, params)
+    bloc_found = Universe.get_sanitizer_method(element)
+    params = instance_exec(params, &bloc_found) if bloc_found.is_a?(Proc)
     params
   end
 
-  def atome_sanitizer(element, params)
-    send("sanitize_#{element}", params)
-  end
-
-  def sanitize_particle(element, value, &user_proc)
-    value = particle_sanitizer(element, value)
-    create_particle(element, value, &user_proc)
-  end
-
   def identity_generator
     { date: Time.now, location: geolocation }
   end
@@ -54,4 +47,8 @@ class Atome
     value = particle.value
     real_atome[property] << value
   end
+
+  def refresh
+    collapse
+  end
 end

data/lib/atome/kernel/essentials.rb

@@ -4,13 +4,6 @@
 class Atome
   private
 
-  def rendering(element_to_render, content, &user_proc)
-    render_engines = @atome[:renderers]
-    render_engines.each do |render_engine|
-      send("#{render_engine}_#{element_to_render}", content, &user_proc)
-    end
-  end
-
   def get(element)
     @atome[element]
   end

data/lib/atome/kernel/universe.rb

@@ -6,7 +6,8 @@ class Universe
   @atome_list = []
   @particle_list = []
   @renderer_list = %i[html browser headless server]
-  @optionals_methods = {}
+  @options = {}
+  @sanitizers = {}
 
   class << self
     attr_reader :atomes, :renderer_list, :atome_list, :particle_list
@@ -15,22 +16,38 @@ class Universe
       instance_variable_get('@particle_list').push(particle)
     end
 
-    def add_optionals_methods(method_name, &method_proc)
+    def add_optional_method(method_name, &method_proc)
       # this method is used to add optional methods
-      instance_variable_get('@optionals_methods').merge!({ method_name => method_proc })
+      instance_variable_get('@options').merge!({ method_name => method_proc })
     end
 
-    def get_optionals_methods(method_name)
+    def get_optional_method(method_name)
       # this method is used to add optional methods
-      instance_variable_get('@optionals_methods')[method_name]
+      instance_variable_get('@options')[method_name]
+    end
+
+    def add_sanitizer_method(method_name, &method_proc)
+      # this method is used to add sanitizer methods
+      instance_variable_get('@sanitizers').merge!({ method_name => method_proc })
+    end
+
+    def get_sanitizer_method(method_name)
+      # this method is used to add optional methods
+      instance_variable_get('@sanitizers')[method_name]
     end
 
     def add_to_atome_list(atome)
       instance_variable_get('@atome_list').push(atome)
     end
 
-    def add_to_atomes(atome)
-      instance_variable_get('@atomes').merge!(atome)
+    def add_to_atomes(id, atome)
+      # instance_variable_get('@atomes').merge!(atome)
+      @atomes[id] = atome
+    end
+
+    def update_atome_id(id, atome, prev_id)
+      @atomes[id] = atome
+      @atomes.delete(prev_id)
     end
 
     def app_identity
@@ -41,9 +58,9 @@ class Universe
       # and finally the object is 3 as this the third object created by the main server
     end
 
-    def change_atome_id(prev_id, new_id)
-      @atomes[new_id] = @atomes.delete(prev_id)
-    end
+    # def change_atome_id(prev_id, new_id)
+    #   @atomes[new_id] = @atomes.delete(prev_id)
+    # end
 
     def delete(id)
       @atomes.delete(id)

data/lib/atome/presets/atome.rb

@@ -22,7 +22,7 @@ class Atome
     generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
     generated_parents = params[:parents] || [id.value]
     params = atome_common(atome_type, generated_id, generated_render, generated_parents, params)
-    color_generated = sanitize_color({ parents: [generated_id], red: 0.3, green: 0.3, blue: 0.3 })
+    color_generated = sanitize(:color, { parents: [generated_id], red: 0.3, green: 0.3, blue: 0.3 })
     params[:color] = color_generated
     Atome.new({ atome_type => params }, &bloc)
   end
@@ -34,7 +34,7 @@ class Atome
     generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
     generated_parents = params[:parents] || [id.value]
     params = atome_common(atome_type, generated_id, generated_render, generated_parents, params)
-    color_generated = sanitize_color({ parents: [generated_id], red: 0.6, green: 0.6, blue: 0.6 })
+    color_generated = sanitize(:color, { parents: [generated_id], red: 0.6, green: 0.6, blue: 0.6 })
     params[:color] = color_generated
     Atome.new({ atome_type => params }, &bloc)
   end
@@ -45,7 +45,7 @@ class Atome
     generated_id = params[:id] || "image_#{Universe.atomes.length}"
     generated_render = params[:renderers] || default_renderer
     generated_parents = params[:parents] || id.value
-
+    # TODO : the line below should get the value from default params Essentials
     temp_default = { renderers: generated_render, id: generated_id, type: :image, parents: [generated_parents],
                      children: [], width: 99, height: 99, path: './medias/images/atome.svg' }
     params = temp_default.merge(params)
@@ -59,8 +59,30 @@ class Atome
     generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
     generated_parents = params[:parents] || [id.value]
     params = atome_common(atome_type, generated_id, generated_render, generated_parents, params)
-    color_generated = sanitize_color({ parents: [generated_id], red: 0.9, green: 0.9, blue: 0.9 })
+    color_generated = sanitize(:color, { parents: [generated_id], red: 0.9, green: 0.9, blue: 0.9 })
     params[:color] = color_generated
     Atome.new({ atome_type => params }, &bloc)
   end
+
+  def element(params = {}, &bloc)
+    atome_type = :element
+    generated_render = params[:renderers] || []
+    generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
+    generated_parents = params[:parents] || [id.value]
+    params = atome_common(atome_type, generated_id, generated_render, generated_parents, params)
+    Atome.new({ atome_type => params }, &bloc)
+  end
+
+  def web(params = {}, &bloc)
+    default_renderer = Essentials.default_params[:render_engines]
+
+    generated_id = params[:id] || "web_#{Universe.atomes.length}"
+    generated_render = params[:renderers] || default_renderer
+    generated_parents = params[:parents] || id.value
+    # TODO : the line below should get the value from default params Essentials
+    temp_default = { renderers: generated_render, id: generated_id, type: :web, parents: [generated_parents],
+                     children: [], width: 120, height: 120, path: 'https://www.youtube.com/embed/usQDazZKWAk' }
+    params = temp_default.merge(params)
+    Atome.new({ image: params }, &bloc)
+  end
 end

data/lib/atome/renderers/browser/atome.rb

@@ -18,7 +18,7 @@ generator.build_render_method(:browser_shape) do
   end.append_to(BrowserHelper.browser_document[:user_view])
   @browser_object = BrowserHelper.browser_document[id_found]
   # Render particles below
-  a_render
+  # collapse
 end
 
 generator.build_render_method(:browser_color) do |_value|
@@ -37,8 +37,9 @@ generator.build_render_method(:browser_color) do |_value|
   # TODO/ use the code below to modify the style tag
   @browser_object = BrowserHelper.browser_document[id_found]
   # now we just have to attach the color atome
-  parents(@atome[:parents])
-  children(@atome[:children])
+  # parents(@atome[:parents])
+  # children(@atome[:children])
+  # collapse
 end
 
 generator.build_render_method(:browser_shadow) do |_value|
@@ -65,31 +66,43 @@ end
 
 generator.build_render_method(:browser_image) do |_user_prc|
   @browser_type = :div
-  id_found = id
+  id_found = @atome[:id]
   DOM do
     img({ id: id_found }).atome
   end.append_to(BrowserHelper.browser_document[:user_view])
   @browser_object = BrowserHelper.browser_document[id_found]
   # Render particles below
-  a_render
-end
-
-generator.build_render_method(:browser_video) do |_value, _user_proc|
-  # @browser_type = :div
-  # id_found = id
-  # DOM do
-  #   video({ id: id_found, autoplay: true, loop: false, muted: true }).atome
-  # end.append_to(BrowserHelper.browser_document[:user_view])
-  # @browser_object = BrowserHelper.browser_document[id_found]
+  # collapse
 end
 
 generator.build_render_method(:browser_text) do |_value, _user_proc|
-  id_found = id
+  id_found = @atome[:id]
   DOM do
     div(id: id_found).atome.text
   end.append_to(BrowserHelper.browser_document[:user_view])
   @browser_object = BrowserHelper.browser_document[id_found]
   @browser_type = :div
   # Render particles below
-  a_render
+  # collapse
+end
+
+generator.build_render_method(:browser_web) do
+  @browser_type = :web
+  id_found = @atome[:id]
+  DOM do
+    iframe({ id: id_found }).atome
+  end.append_to(BrowserHelper.browser_document[:user_view])
+  @browser_object = BrowserHelper.browser_document[id_found]
+  @browser_object.attributes[:allow] = 'accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture'
+  @browser_object.attributes[:allowfullscreen] = true
+  @html_type = :web
 end
+
+generator.build_render_method(:browser_video) do |_value, _user_proc|
+  @browser_type = :div
+  id_found = @atome[:id]
+  DOM do
+    video({ id: id_found, autoplay: false, loop: false, muted: true }).atome
+  end.append_to(BrowserHelper.browser_document[:user_view])
+  @browser_object = BrowserHelper.browser_document[id_found]
+end