atome 0.4.5.4 → 0.4.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49cc8d868d75099b8958e82985a3fbf1c43eaea349619ffa01e810fd9ea10ca0
-  data.tar.gz: 5e9b7460dea168d8fb9b21de448edbb57deed81173fc1d04bf95f12262e80ba7
+  metadata.gz: c05926a443ccc93706250a217fe46a42d571f0c97cb9549fd445036b8cb0ff93
+  data.tar.gz: f9c922aaab0da02ff843af4f721f7370b538d39a4afd238338e9a6ad7071c34d
 SHA512:
-  metadata.gz: 12f981205e19cfc5f4243e8498c190b7b5903009660f0c68219c4eaee95195b47e0ff69fcecc67c69cd7624b66a8dd10340249dc7bc9576682d05031ec497ed3
-  data.tar.gz: ee6814778ba2ca00d75a7fb714847c680982ce20ffccc2df34160554340f1cb400efaab3a996d1820e91879ba72a0430f5bd90c2eb2463c39a25a2e1becdc540
+  metadata.gz: 6067a7cc1206d75a5245c3098976993745d17bf296ae6931ed3a3eda13d885389c89e7f47af061a506092866ec7a637e4e848089caefc74595693f90b18dd46d
+  data.tar.gz: 02a14025506b36a050d885fb5b09be305f011a3f2a067561994608a7e77fa236d18a62f3d92293b311459418fd384645b9f3447fc462881da2c77e3db3e27c09

data/Gemfile

@@ -9,6 +9,4 @@ gem "rake", "~> 13.0"
 
 gem "minitest", "~> 5.0"
 gem 'rubocop', group: 'development'
-gem 'rubocop', group: 'development'
-gem 'rubocop', group: 'development'
-gem 'rubocop', group: 'development'
+

data/Rakefile

@@ -13,6 +13,7 @@
 # task default: :test
 
 task :test do
+  FileUtils.copy_entry('vendor/assets/build/js/atome/', 'test/test_app/build/js/atome/')
   `gem cleanup atome;yes | gem uninstall atome ;gem build atome.gemspec;gem install atome`
   `cd test/test_app;atome update;atome run guard`
 end

data/app_builder_helpers/Rakefile

@@ -195,6 +195,8 @@ end
 task :system_updater, :user_project_path, :production do |_t, args|
   user_project_path = args[:user_project_path]
   production = args[:production]
+  gem_location = File.join(File.dirname(__FILE__))
+  build_libraries(user_project_path, gem_location)
   build_common_libraries(user_project_path, production)
 end
 

data/lib/atome/atome_native_extensions.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-require 'atome/extensions/sha'
-require 'atome/extensions/ping'
-require 'atome/extensions/geolocation'
+require 'atome/kernel/helpers/sha'
+require 'atome/kernel/helpers/ping'
+require 'atome/kernel/helpers/geolocation'

data/lib/atome/extensions/helper.rb

@@ -1,27 +1,12 @@
-def grab(val)
-  Atome.grab(val)
-end
 
 
-def read_ruby(file)
-  `
-fetch('medias/rubies/'+#{file})
-  .then(response => response.text())
-  .then(text => Opal.eval(text))
-`
-end
-
-def read_text(file)
-  `
-fetch('medias/rubies/'+#{file})
-  .then(response => response.text())
-  .then(text => console.log(text))
-`
+def grab(val)
+  Atome.grab(val)
 end
 
 
 def read(file, action=:text)
-  send("read_#{action}", file)
+  Internal.send("read_#{action}", file)
 end
 
 def wait(seconds)
@@ -49,19 +34,6 @@ if (++x ===#{repeat} )  {
 end
 
 
-
-`
-const atome = {
-    jsSchedule: function (years, months, days, hours, minutes, seconds, proc) {
-        const now = new Date();
-        const formatedDate = new Date(years, months - 1, days, hours, minutes, seconds);
-        const diffTime = Math.abs(formatedDate - now);
-        setTimeout(function () {
-            Opal.Object.$schedule_callback(proc);
-        }, diffTime);
-    }}
-`
-
 def schedule(date, &proc)
   date = date.to_s
   delimiters = [",", " ", ":", "-"]
@@ -120,4 +92,21 @@ end
 
 def schedule_callback(proc)
   instance_exec(&proc) if proc.is_a?(Proc)
+end
+
+def play_video(params, &proc)
+  params[:atome].html_object.play
+  # TODO : change timeupdate for when possible requestVideoFrameCallback (opal-browser/opal/browser/event.rb line 36)
+  video_callback = params[:atome].bloc # this is the video callback not the play callback
+  play_callback = params[:proc] # this is the video callback not the play callback
+  params[:atome].html_object.on(:timeupdate) do |e|
+    # e.prevent # Prevent the default action (eg. form submission)
+    # You can also use `e.stop` to stop propagating the event to other handlers.
+    instance_exec(params[:atome].html_object.currentTime, &video_callback) if video_callback.is_a?(Proc)
+    instance_exec(params[:atome].html_object.currentTime, &play_callback) if play_callback.is_a?(Proc)
+  end
+end
+
+def pause_video(params, &proc)
+  params[:atome].html_object.pause
 end

data/lib/atome/kernel/atome.rb

@@ -19,6 +19,7 @@ class Atome
   include Sanitizer
   include ServerRenderer
   include Render
+  include Internal
   # include OpalRenderer
   # include HeadlessRenderer
   def self.atome(params)
@@ -79,20 +80,20 @@ class Atome
     end
   end
 
-  def initialize(params = {}, &proc)
-    # We initialize the renderer here
-    @render=[]
+  def initialize(params = {}, &bloc)
+    @render = []
+    @child = []
+    @html_type = :unset
     # # 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)
+      send(atome, values, &bloc)
     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

@@ -3,8 +3,8 @@
 # generators
 
 Genesis.particle_creator(:html_type)
-Genesis.particle_creator(:html_object)
 
+Genesis.particle_creator(:html_object)
 
 Genesis.atome_creator(:shape)
 
@@ -42,6 +42,20 @@ end
 
 Genesis.atome_creator(:shadow)
 
+Genesis.atome_creator(:video) do |params, &proc|
+  # todo:  factorise code below
+  if params
+    default_renderer = Sanitizer.default_params[:render]
+    generated_id = params[:id] || "video_#{Universe.atomes.length}"
+    generated_render = params[:render] || default_renderer unless params[:render].instance_of? Hash
+    generated_parent = params[:parent] || id
+    default_params = { render: [generated_render], id: generated_id, type: :video, parent: [generated_parent],
+                       path: './medias/videos/video_missing.mp4', left: 139, top: 333, width: 199, height: 199 }
+    params = default_params.merge(params)
+  end
+  params
+end
+
 # Example below
 
 # Genesis.atome_creator(:color) do |params|
@@ -70,8 +84,7 @@ Genesis.atome_creator(:shadow)
 #   # puts "optional color_getter_pre_proc\n"
 # end
 
-Genesis.particle_creator(:id) do
-end
+Genesis.particle_creator(:id)
 Genesis.particle_creator(:left)
 Genesis.particle_creator(:right)
 Genesis.particle_creator(:top)
@@ -86,8 +99,12 @@ Genesis.particle_creator(:type)
 Genesis.particle_creator(:smooth)
 Genesis.particle_creator(:blur)
 Genesis.particle_creator(:touch)
+Genesis.particle_creator(:play)
+Genesis.particle_creator(:pause)
+Genesis.particle_creator(:time)
+
 # Genesis.atome_creator_option(:type_pre_render_proc) do |params|
-#   # alert "it works and get #{params}"
+#   # "it works and get #{params}"
 #   params[:value]
 # end
 
@@ -98,21 +115,47 @@ Genesis.particle_creator(:touch)
 
 Genesis.particle_creator(:render)
 Genesis.particle_creator(:drm)
-Genesis.particle_creator(:parent)
+
+Genesis.particle_creator(:child)
+
+Genesis.particle_creator(:parent) do |parents|
+  parents.each do |parent|
+    #TODO : create a root atome instead of using the condition below
+    if parent != :user_view
+      grab(parent).child << id
+    end
+  end
+  parents
+end
 
 Genesis.atome_creator_option(:parent_pre_render_proc) do |params|
+  current_atome = params[:atome]
   unless params[:value].instance_of? Array
     params[:value] = [params[:value]]
   end
-  params[:value]
+  current_atome.instance_variable_set("@parent", params[:value])
 end
+
 Genesis.particle_creator(:date)
 Genesis.particle_creator(:location)
 
+Genesis.atome_creator_option(:id_pre_render_proc) do |params|
+  new_id = params[:value]
+  current_atome = params[:atome]
+  old_id = current_atome.id
+  current_atome.instance_variable_set('@id', new_id)
+  # we change id id the atomes hash
+  Universe.change_atome_id(old_id, new_id)
+  current_atome.html_object.id = new_id if current_atome.html_object
+
+end
+
+
 # generate renderers
 
 Genesis.generate_html_renderer(:type) do |value, atome, proc|
   send("#{value}_html", value, atome, proc)
+  value
 end
 
 Genesis.generate_html_renderer(:shape) do |value, atome, proc|
@@ -128,7 +171,9 @@ 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>")
+  # we remove previous unused style tag
+  $document[id].remove if $document[id]
+  $document.head << DOM("<style atome='#{type}'  id='#{id}'></style>")
 end
 
 Genesis.generate_html_renderer(:red) do |value, atome, proc|
@@ -173,29 +218,17 @@ Genesis.generate_html_renderer(:alpha) do |value, atome, proc|
   $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(:drm)
 
 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
+    atome.html_decision(@html_type, value, id)
   end
 end
+
+
+
 Genesis.generate_html_renderer(:id) do |value, atome, proc|
   # send("#{value}_html", value, atome, proc)
 end
@@ -224,11 +257,8 @@ 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.particle_creator(:rotate)
+
 Genesis.generate_html_renderer(:rotate) do |value, atome, proc|
   @html_object.style[:transform] = "rotate(#{value}deg)" unless @html_type == :style
 end
@@ -255,30 +285,17 @@ Genesis.generate_html_renderer(:touch) do |value, atome, 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
+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: false }).atome
+  end.append_to($document[:user_view])
+  @html_object = $document[id_found]
+  @html_type = :video
 end
 
+# overflow
 Genesis.particle_creator(:overflow)
 Genesis.generate_html_renderer(:overflow) do |value, atome, proc|
   @html_object.style[:overflow] = value unless @html_type == :style
@@ -289,10 +306,7 @@ 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)
@@ -305,40 +319,41 @@ end
 
 # text
 
-Genesis.atome_creator(:text)
+Genesis.atome_creator(:text) do |params|
+  # TODO: factorise code below
+  if params
+    default_renderer = Sanitizer.default_params[:render]
+    generated_id = params[:id] || "text_#{Universe.atomes.length}"
+    generated_render = params[:render] || default_renderer unless params[:render].instance_of? Hash
+    generated_parent = params[:parent] || id
+
+    default_params = { render: [generated_render], id: generated_id, type: :text, parent: [generated_parent],
+                       visual: { size: 33 }, data: "hello world", left: 39, top: 33,
+                       color: { render: [generated_render], id: "color_#{generated_id}", type: :color,
+                                red: 0.09, green: 1, blue: 0.12, alpha: 1 }
+    }
+    params = default_params.merge(params)
+    params
+  end
+  # params
+end
 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
+    div(id: id_found).atome.text
   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|
@@ -346,25 +361,24 @@ Genesis.atome_creator_option(:particles_getter_pre_proc) do |params|
   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
+    particles_hash[particle_found.sub('@', '')] = 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')
+  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]
+  sanitized_particles[:parent] = [atome_found.id]
   atome_found.send(atome_type, sanitized_particles)
   params[:value]
 end
@@ -373,6 +387,7 @@ 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)
@@ -380,8 +395,123 @@ Genesis.generate_html_renderer(:web) do |value, atome, proc|
     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_object.attributes[:allow] = 'accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture'
+  @html_object.attributes[:allowfullscreen] = true
   @html_type = :web
 end
 
+Genesis.particle_creator(:data)
+
+Genesis.generate_html_renderer(:data) do |value, atome, proc|
+  # TODO: create a method for each type
+  send("#{type}_data", value)
+end
+
+Genesis.particle_creator(:code)
+Genesis.atome_creator_option(:code_pre_render_proc) do |params|
+  def get_binding
+    binding
+  end
+
+  str = params[:value][:code]
+  eval str, get_binding, __FILE__, __LINE__
+  params[:value]
+end
+Genesis.particle_creator(:on)
+
+Genesis.generate_html_renderer(:on) do |value, atome, proc|
+  @html_object.on(value) do |e|
+    instance_exec(e, &proc) if proc.is_a?(Proc)
+  end
+end
+
+Genesis.atome_creator_option(:shape_post_save_proc) do |params|
+  current_atome = params[:atome]
+  #FIXME: look why we have to look in [:value][:value] this looks suspect
+  bloc_found = params[:value][:value][:bloc]
+  current_atome.instance_exec(params, &bloc_found) if bloc_found.is_a?(Proc)
+  params
+end
+
+Genesis.atome_creator_option(:text_post_save_proc) do |params|
+  current_atome = params[:atome]
+  #FIXME: look why we have to look in [:value][:value] this looks suspect
+  bloc_found = params[:value][:value][:bloc]
+  current_atome.instance_exec(params, &bloc_found) if bloc_found.is_a?(Proc)
+  params
+end
+
+Genesis.atome_creator_option(:play_pre_render_proc) do |params|
+  params[:atome].send("play_#{params[:atome].type}", params)
+end
+
+Genesis.atome_creator_option(:pause_pre_render_proc) do |params|
+  params[:atome].send("pause_#{params[:atome].type}", params)
+  proc_found = params[:proc]
+  params[:atome].instance_exec('::call back from pause render', &proc_found) if proc_found.is_a?(Proc)
+end
+
+Genesis.generate_html_renderer(:time) do |value, atome, proc|
+  # params[:atome].html_object.currentTime= 33
+  @html_object.currentTime = value
+end
+
+#drag
+Genesis.generate_html_renderer(:drag) do |value, atome, proc|
+  alert ("this is very strange that I had a style tag please check")
+  instance_exec(&proc) if proc.is_a?(Proc)
+  @html_type = :style
+  $document.head << DOM("<style atome='#{type}' id='#{id}'></style>")
+end
+Genesis.particle_creator(:lock)
+Genesis.particle_creator(:target)
+Genesis.atome_creator(:drag) do |params|
+  # TODO: factorise code below
+  if params
+    default_renderer = Sanitizer.default_params[:render]
+    generated_id = params[:id] || "drag_#{Universe.atomes.length}"
+    generated_render = params[:render] || default_renderer unless params[:render].instance_of? Hash
+    generated_parent = params[:parent] || id
+    default_params = { render: [generated_render], id: generated_id, type: :drag, parent: [generated_parent], target: [generated_parent]
+    }
+    params = default_params.merge(params)
+    params
+  end
+  params
+end
+Genesis.particle_creator(:remove)
+Genesis.particle_creator(:fixed)
+Genesis.particle_creator(:max)
+Genesis.particle_creator(:inside)
+Genesis.atome_creator_option(:remove_pre_render_proc) do |params|
+  type_found = params[:atome].type
+  current_atome = params[:atome]
+  particle_to_remove = params[:value]
+  current_atome.send("#{type_found}_remove_#{particle_to_remove}", current_atome)
+end
+Genesis.atome_creator_option(:max_pre_render_proc) do |params|
+  current_atome = params[:atome]
+  current_atome.constraint_helper(params, current_atome, :max)
+end
+Genesis.atome_creator_option(:inside_pre_render_proc) do |params|
+  current_atome = params[:atome]
+  params[:value] = grab(params[:value]).html_object
+  current_atome.constraint_helper(params, current_atome, :max)
+end
+Genesis.atome_creator_option(:lock_pre_render_proc) do |params|
+  current_atome = params[:atome]
+  current_atome.constraint_helper(params, current_atome, :lock)
+end
+Genesis.atome_creator_option(:fixed_pre_render_proc) do |params|
+  current_atome = params[:atome]
+  current_atome.constraint_helper(params, current_atome, :fixed)
+end
+Genesis.generate_html_renderer(:target) do |targets, atome, proc|
+  targets.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.add_class(id)
+  end
+  html_drag_helper(atome, {})
+end
+