atome 0.5.1.9 → 0.5.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 108def7ca1abaccd885638fdea127766d1f97c4ac2559faee3eec445b52bdbac
-  data.tar.gz: bf00b2ccb9e339a08c16221964b11cd6c2440cc415f6886bef2e4c18ac1967f1
+  metadata.gz: f484bac3226108b4f85b673ca7351becb12af457707ef7cca080058c15b13ef5
+  data.tar.gz: a7c42ee2a67b75ed1d0099bf082888ab50bbe2a56e2c68e93436f839ab363c89
 SHA512:
-  metadata.gz: 3ecf2a30c425a8b46f88f08cd5b436d6298dd36b8db8984a50190a15a360639c6ac161725c3c5a7b327c740927032315a46a988fbdf5790fe830e31a5d22d4a4
-  data.tar.gz: 5585b8e500d715c86799172790bcc7be0bbc67cfbc438a6fedf03be8aecfea287df999588d4771d4c50f6a62dbad35fa2002f387b425fc602de776c9ff310ca0
+  metadata.gz: b9f6e623de170446b7396d38240cd02d92e0943e1f45d6f51161c4c2dc4057ab13c32e4273e04730708f8da42d429c3865175339e102a82f797bb476b4a4dfb1
+  data.tar.gz: 4319997d39d49fa04541cf888e69d23db768455969a55944531ce70f55f889d0ffb05aa3db8de5db0cdaa0117cb6640ea401a73e6b6f80a46788fa8b8dcd7450

data/Rakefile

@@ -14,21 +14,38 @@ task default: :test
 task :test_browser do
   FileUtils.copy_entry('vendor/assets/build/js/', 'test/test_app/build/js/')
   FileUtils.copy_entry('vendor/assets/build/css/', 'test/test_app/build/css/')
-  FileUtils.copy_entry('vendor/assets/build/css/', 'test/test_app/build/medias/')
+  FileUtils.copy_entry('vendor/assets/build/medias/', 'test/test_app/build/medias/')
   `gem cleanup atome;yes | gem uninstall atome ;gem build atome.gemspec;gem install atome`
   `cd test/test_app;atome update;atome run guard`
 end
 
-task :run_browser do
-  `cd test/test_app;atome run guard`
-end
+
 
 task :test_server do
   FileUtils.copy_entry('vendor/assets/build/js/', 'test/test_app/build/js/')
   FileUtils.copy_entry('vendor/assets/build/css/', 'test/test_app/build/css/')
-  FileUtils.copy_entry('vendor/assets/build/css/', 'test/test_app/build/medias/')
+  FileUtils.copy_entry('vendor/assets/build/medias/', 'test/test_app/build/medias/')
   `gem cleanup atome;yes | gem uninstall atome ;gem build atome.gemspec;gem install atome`
   `cd test/test_app;atome update;atome run server`
 end
 
+task :run_browser do
+  `cd test/test_app;atome run guard`
+end
+
+task :run_server do
+  `cd test/test_app;atome run server guard`
+end
+
+task :run_example do
+  FileUtils.copy_entry('vendor/assets/build/medias/rubies/examples/', 'test/test_app/build/medias/rubies/examples/')
+  `cd test/test_app;atome run `
+end
+
+task :run_example_server do
+  FileUtils.copy_entry('vendor/assets/build/medias/rubies/examples/', 'test/test_app/build/medias/rubies/examples/')
+  `cd test/test_app;atome run server `
+end
+
+
 task default: :test

data/lib/atome/atome.rb

@@ -15,23 +15,25 @@ class Atome
     atomes.each_value do |elements|
       # the instance variable below contain the id all any atomes that need to be informed when changes occurs
       @broadcast = {}
-      @at_time = {}
+      # @at_time = {}
       # now we store the proc in a an atome's property called :bloc
       elements[:code] = atomes_proc if atomes_proc
       @atome = elements
       # we initiate the rendering, eg for for browser we will call :browser_type generate method in identity.rb file
-      create_particle(:type, @atome[:type])
+      create_particle(:type)
+      set_type(@atome[:type])
       collapse
     end
   end
 
   def new_particle(element, &method_proc)
     Atome.define_method element do |params = nil, &user_proc|
-      if params
+      if params || params == false
         # 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)
         params = sanitize(element, params)
-        create_particle(element, params, &user_proc)
+        create_particle(element)
+        send("set_#{element}", params, &user_proc)
       else
         get_particle(element, &user_proc)
       end
@@ -42,20 +44,27 @@ class Atome
     Atome.define_method "#{element}=" do |params = nil, &user_proc|
       instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
       params = sanitize(element, params)
-      create_particle(element, params, &user_proc)
+      particle_creation(element, params, &user_proc)
     end
   end
 
+  def atome_creation_pre_treatment(element, params, &user_proc)
+    params = sanitize(element, params)
+    create_atome(element)
+    send("set_#{element}", params, &user_proc)
+  end
+
   def new_atome(element, &method_proc)
     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 = sanitize(element, params)
-        Atome.new({ element => params })
+        atome_creation_pre_treatment(element, params, &user_proc)
       else
         get_atome(element, &user_proc)
       end
     end
+    # the method below generate Atome method creation at Object level
+    create_method_at_object_level(element)
   end
 
   def new_render_engine(renderer_name, &method_proc)
@@ -66,39 +75,52 @@ class Atome
 
   def run_optional_proc(proc_name, atome = self, value = '', &user_proc)
     option_found = Universe.get_optional_method(proc_name)
-    atome.instance_exec(value,user_proc, &option_found) if option_found.is_a?(Proc)
+    atome.instance_exec(value, user_proc, atome, &option_found) if option_found.is_a?(Proc)
   end
 
   def inject_value(element, value)
+    # attention :  please keep the method 'inject_value' available as it is sometimes needed to access it directly
     @atome[element] = value
   end
 
-  def store_value(element, value)
+  def store_value(element)
     # this method save the value of the particle and broadcast to the atomes listed in broadcast
-    broadcasting(element, value)
-    inject_value(element, value)
+    broadcasting(element, @atome[element])
+    inject_value(element, @atome[element])
   end
 
   public
 
   # the line below is used for ephemera atomes
   attr_accessor :property, :value, :real_atome, :user_proc
-  attr_reader :atome, :structure, :at_time
+  attr_reader :atome, :structure#, :at_time
 
   def set(value)
     @real_atome[@property] = value
   end
 
-  def create_particle(element, value, &user_proc)
-    return false unless security_pass(element, value)
-
-    run_optional_proc("pre_render_#{element}".to_sym, self, value, &user_proc)
-    rendering(element, value, &user_proc)
-    run_optional_proc("post_render_#{element}".to_sym, self, value, &user_proc)
-    store_value(element, value)
+  def particle_creation(element, params, &user_proc)
+    return false unless security_pass(element, params)
+
+    # we create a proc holder of any new particle if user pass a bloc
+    store_code_bloc(element, &user_proc) if user_proc
+    # we store the params immediately into the atome so optionals methods can access and modify it
+    @atome[element] = params
+    run_optional_proc("pre_render_#{@atome[:type]}".to_sym, self, @atome[element], &user_proc)
+    run_optional_proc("pre_render_#{element}".to_sym, self, @atome[element], &user_proc)
+    rendering(element, @atome[element], &user_proc)
+    run_optional_proc("post_render_#{@atome[:type]}".to_sym, self, @atome[element], &user_proc)
+    run_optional_proc("post_render_#{element}".to_sym, self, @atome[element], &user_proc)
+    store_value(element)
     self
   end
 
+  def create_particle(element)
+    Atome.define_method "set_#{element}" do |params, &user_proc|
+      particle_creation(element, params, &user_proc)
+    end
+  end
+
   def get(element)
     @atome[element]
   end
@@ -109,7 +131,8 @@ class Atome
     virtual_atome.real_atome = @atome
     virtual_atome.property = element
     virtual_atome.user_proc = user_proc
-    run_optional_proc("pre_get_#{element}".to_sym, virtual_atome, &user_proc)
+    run_optional_proc("pre_get_#{@atome[:type]}".to_sym, "virtual_atome", &user_proc)
+    run_optional_proc("pre_get_#{element}".to_sym, self, "virtual_atome", &user_proc)
     virtual_atome
   end
 
@@ -123,7 +146,9 @@ class Atome
   end
 
   def create_atome(new_atome)
-    Atome.new(new_atome)
+    Atome.define_method "set_#{new_atome}" do |params, &user_proc|
+      Atome.new({ new_atome => params }, &user_proc)
+    end
   end
 
   Universe.connected

data/lib/atome/extensions/atome.rb

@@ -12,30 +12,9 @@ def circle(params = {}, &proc)
   grab(:view).circle(params, &proc)
 end
 
-def text(params = {}, &bloc)
-  grab(:view).text(params, &bloc)
-end
-
-def image(params = {}, &bloc)
-  grab(:view).image(params, &bloc)
-end
-
-def video(params = {}, &bloc)
-  grab(:view).video(params, &bloc)
-end
-
-def color(params = {}, &bloc)
-  grab(:view).color(params, &bloc)
-end
-
-def element(params = {}, &bloc)
-  grab(:view).element(params, &bloc)
-end
-
-def shadow(params = {}, &bloc)
-  grab(:view).shadow(params, &bloc)
-end
-
-def web(params = {}, &bloc)
-  grab(:view).web(params, bloc)
+# the method below generate Atome method creation at Object level
+def create_method_at_object_level(element)
+  Object.define_method element do |params = nil, &user_proc|
+    grab(:view).send(element, params, &user_proc)
+  end
 end

data/lib/atome/extensions/geolocation.rb

@@ -11,4 +11,3 @@ class Atome
     results.first.coordinates
   end
 end
-

data/lib/atome/extensions/matrix.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+# powerful and simple to use table and list generator
+class Matrix
+  attr_accessor :matrix
+
+  def create_matrix_back( id, style)
+    @matrix = Atome.new(
+      shape: { type: :shape, renderers: [:browser], id: id, parents: [:view], children: [:matrix_color],
+               overflow: :auto }
+    )
+    @matrix.style(style)
+  end
+
+  def create_matrix_colors
+    Atome.new({ color: { renderers: [:browser], id: :matrix_color, type: :color, parents: [], children: [],
+                         red: 0, green: 1, blue: 1, alpha: 1 } })
+
+    Atome.new({ color: { renderers: [:browser], id: :cell_color, type: :color, parents: [], children: [],
+                         red: 1, green: 0.15, blue: 0.7, alpha: 1 } })
+  end
+
+  def create_cells(id, cell_number, number_of_cells, style)
+    while cell_number < number_of_cells
+      @matrix_dataset[cell_number] = []
+      @cells << a = Atome.new(
+        shape: { type: :shape, renderers: [:browser], id: id + "_#{cell_number}", parents: [id],
+                 children: [:cell_color] }
+      )
+      a.style(style)
+      cell_number += 1
+    end
+  end
+
+  def initialize(params)
+    default = { col: 4, row: 4, size: 333, margin: 12, name: :matrix, parent: :view }
+    params = default.merge(params)
+    nb_of_rows = params[:row]
+    nb_of_cols = params[:col]
+    matrix_width = params[:width]
+    matrix_height = params[:height]
+
+    @matrix_dataset = []
+    @matrix_margin = params[:margin]
+    params[:id] = :matrix unless params[:id]
+    @matrix_id = params[:id]
+    # styles
+    @matrix_style = params[:matrix_style]
+    @cell_style = params[:cell_style]
+    # Colors
+    create_matrix_colors
+    # now we create the background
+    create_matrix_back( @matrix_id, @matrix_style)
+
+    @nb_of_rows = nb_of_rows.to_i
+    @nb_of_cols = nb_of_cols.to_i
+    number_of_cells = @nb_of_rows * @nb_of_cols
+    @cells = []
+    cell_number = 0
+    create_cells(@matrix_id, cell_number, number_of_cells, @cell_style)
+
+    resize_matrix({ width: matrix_width, height: matrix_height })
+  end
+
+  def width(val = nil)
+    if val
+      resize_matrix({ height: height, width: val })
+    else
+      @matrix.width.value
+    end
+
+  end
+
+  def height(val = nil)
+    if val
+      resize_matrix({ width: width, height: val })
+    else
+      @matrix.height.value
+    end
+  end
+
+  def left(val)
+    @matrix.left(val)
+  end
+
+  def right(val)
+    @matrix.right(val)
+  end
+
+  def resize_matrix(params)
+    matrix_width = params[:width]
+    matrix_height = params[:height]
+    cell_width = (matrix_width / @nb_of_cols) - @matrix_margin
+    cell_height = (matrix_height / @nb_of_rows) - @matrix_margin
+    row = -1
+    @cells.each_with_index do |cell, index|
+      cell.height = cell_height
+      cell.width = cell_width
+      row += 1 if index.modulo(@nb_of_cols).zero?
+      cell.left(index % @nb_of_cols * (cell_width + @matrix_margin) + @matrix_margin)
+      cell.top(row * (cell_height + @matrix_margin) + @matrix_margin)
+    end
+
+    @matrix.width = matrix_width + @matrix_margin
+    @matrix.height = matrix_height + @matrix_margin
+  end
+
+  def get_cell(id)
+    grab("#{@matrix_id}_#{id}")
+  end
+
+  def delete(val = true)
+    @matrix.delete(true) if val
+  end
+
+  attr_reader :cells
+
+  def name
+    @matrix.name
+  end
+
+  def get_cell_data(codes, cell_nb)
+    codes.each do |proc|
+      if proc.is_a? Proc
+        assign(cell_nb, &proc)
+      end
+    end
+  end
+
+  def add(params)
+    nb_of_cols = @nb_of_cols + params[:columns].to_i
+    nb_of_rows = @nb_of_rows + params[:rows].to_i
+    current_id = @matrix.atome[:id]
+    # we delete all children to unbind any event
+    @cells.each do |cell|
+      cell.delete(true)
+      cell.unbind(:all)
+    end
+    temp_id = "#{current_id}_temporary"
+    @matrix.id = temp_id
+    old_matrix=grab(temp_id)
+
+    old_matrix.delete(true)
+
+
+    Matrix.new({ col: nb_of_cols, row: nb_of_rows, width: 300, height: 300, id: current_id,  margin: @matrix_margin,
+                 matrix_style: @matrix_style,
+                 cell_style: @cell_style
+               })
+
+    @matrix_dataset.each_with_index do |cell_data, index|
+      get_cell_data(cell_data, index)
+    end
+  end
+
+  def assign(cell_nb = nil, &proc)
+    current_cell = grab("#{@matrix_id}_#{cell_nb}")
+    if proc
+      @matrix_dataset[cell_nb] << proc
+      current_cell.instance_exec(&proc) if proc.is_a? Proc
+    else
+      @matrix_dataset[cell_nb]
+    end
+  end
+
+  def reformat(params)
+    @nb_of_rows = params[:rows]
+    @nb_of_cols = params[:cols]
+    resize_matrix({ height: height, width: width })
+  end
+end

data/lib/atome/extensions/ping.rb

@@ -1,17 +1,15 @@
 # frozen_string_literal: true
 
+# ping method
 class Atome
-  def ping(address, my_proc: false)
-    # if  RUBY_ENGINE.downcase != 'opal'
-    def up?(host, my_proc)
-      check = Net::Ping::External.new(host)
-      if check.ping?
-        puts "ping respond!! "
-      end
-    end
+  def up?(host, _my_proc)
+    check = Net::Ping::External.new(host)
+    return unless check.ping?
+
+    puts 'ping respond!!'
+  end
 
-    chost = address
-    puts up?(chost, my_proc) # prints "true" if ping replies
-    # end
+  def ping(address, my_proc: false)
+    puts up(address, my_proc) # prints "true" if ping replies
   end
 end

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

@@ -2,15 +2,18 @@
 
 generator = Genesis.generator
 
+generator.build_atome(:animation)
 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,
+                     attach: parent_found,
                      red: 0, green: 0, blue: 0, alpha: 1 }
   params = create_color_hash(params) unless params.instance_of? Hash
-  default_params.merge!(params)
+  new_params = default_params.merge!(params)
+  atome[:color] = new_params
+  new_params
 end
 
 generator.build_sanitizer(:video) do |params|
@@ -21,6 +24,15 @@ generator.build_sanitizer(:video) do |params|
   default_params.merge!(params)
 end
 generator.build_atome(:shadow)
+
+generator.build_sanitizer(:shadow) do |params|
+  parent_found = found_parents_and_renderers[:parent]
+  render_found = found_parents_and_renderers[:renderers]
+  default_params = { renderers: render_found, id: "shadow_#{Universe.atomes.length}", type: :shadow,
+                     attach: parent_found,
+                     red: 0, green: 0, blue: 0, alpha: 1 , blur: 3, left: 3, top: 3}
+  default_params.merge!(params)
+end
 generator.build_atome(:shape)
 generator.build_atome(:text)
 generator.build_atome(:image)

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

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-generator = Genesis.generator
+# generator = Genesis.generator

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

@@ -2,20 +2,49 @@
 
 generator = Genesis.generator
 
+# touch
 generator.build_particle(:touch)
-generator.build_particle(:play)
+# video
+generator.build_particle(:play) do
+  @atome[:pause] = :false
+end
 generator.build_particle(:time)
-generator.build_particle(:pause)
+generator.build_particle(:pause) do
+  @atome[:play] = :false
+end
 generator.build_particle(:on)
 generator.build_particle(:fullscreen)
 generator.build_particle(:mute)
 # TODO : add the at event to ny particle : (width, left, ...) maybe use monitor particle
-generator.build_particle(:at)
+# generator.build_particle(:at)
+# drag
 generator.build_particle(:drag)
 generator.build_sanitizer(:drag) do |params|
   params = { move: true } if params == true
   params
 end
+# sort
 generator.build_particle(:sort) do |_value, sort_proc|
   @sort_proc = sort_proc
 end
+
+# animation
+generator.build_particle(:targets)
+generator.build_particle(:start)
+generator.build_option(:pre_render_start) do |_value, user_proc|
+  @animation_start_proc = user_proc
+end
+generator.build_particle(:stop)
+generator.build_option(:pre_render_stop) do |_value, user_proc|
+  @animation_stop_proc = user_proc
+end
+generator.build_particle(:begin)
+generator.build_particle(:end)
+generator.build_particle(:duration)
+generator.build_particle(:mass)
+generator.build_particle(:damping)
+generator.build_particle(:stiffness)
+generator.build_particle(:velocity)
+generator.build_particle(:repeat)
+generator.build_particle(:ease)
+generator.build_particle(:unbind)

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

@@ -25,3 +25,35 @@ generator.build_option(:pre_render_parents) do |parents_id_found|
     parents_found.children << id if parents_found
   end
 end
+generator.build_particle(:name)
+
+generator.build_particle(:active)
+
+generator.build_particle(:attach) do |parents|
+  parents.each do |parent|
+    grab(parent).atome[:attached] = [atome[:id]]
+  end
+end
+
+generator.build_particle(:attached) do |targets|
+  targets.each do |target|
+    grab(target).attach([atome[:id]])
+  end
+end
+
+generator.build_particle(:intricate, :array)
+
+
+generator.build_particle(:clones) do |clones_found|
+  clones_found.each_with_index  do |clone_found, index|
+    particles_intricated= clone_found[:intricate] ||= [:width]
+    clone_id="#{particles[:id]}_clone_#{index}"
+    original_id=atome[:id]
+    clone_found[:id] = clone_id
+    clone_found = particles.merge(clone_found)
+    cloned_atome=Atome.new({ clone: clone_found })
+    cloned_atome.monitor({ atomes: [original_id], particles: particles_intricated}) do |_atome, particle, value|
+      cloned_atome.send(particle,value)
+    end
+  end
+end

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

@@ -6,5 +6,26 @@ generator.build_particle(:red)
 generator.build_particle(:green)
 generator.build_particle(:blue)
 generator.build_particle(:alpha)
+generator.build_particle(:diffusion)
 generator.build_particle(:visual)
 generator.build_particle(:overflow)
+generator.build_particle(:edit)
+generator.build_particle(:style)
+generator.build_option(:pre_render_style) do |styles_send, _user_proc|
+  styles_send.each do |particle_send, value|
+    send(particle_send, value)
+  end
+end
+generator.build_particle(:hide)
+
+generator.build_particle(:remove) do |particle_to_remove|
+  case particle_to_remove
+  when :color
+    send(particle_to_remove, :black)
+  when :shadow
+    # TODO : code to write
+    puts 'code to write'
+  else
+    send(particle_to_remove, 0)
+  end
+end

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

@@ -11,3 +11,4 @@ generator.build_particle(:top)
 generator.build_particle(:bottom)
 generator.build_particle(:rotate)
 generator.build_particle(:direction)
+generator.build_particle(:center)

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+generator = Genesis.generator
+# create particles
+generator.build_particle(:markers, :hash)

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

@@ -11,8 +11,23 @@ end
 generator.build_particle(:broadcast)
 generator.build_particle(:additional)
 generator.build_particle(:data)
-generator.build_particle(:delete) do
-  Universe.delete(@atome[:id])
+generator.build_particle(:delete) do |params|
+  if params == true
+    # the machine delete the current atome
+    Universe.delete(@atome[:id])
+  elsif params[:id]
+    # the machine try to an atome by it's ID and delete it
+    grab(params[:id]).delete(true)
+  elsif instance_of? Hash
+    # the machine try to find the sub particle id and remove it eg a.delete(monitor: :my_monitor) remove the monitor
+    # with id my_monitor
+    params.each do |param, value|
+      atome[param][value] = nil
+    end
+  else
+    # the machine try to reset the current particle(params), eg a.delete(:left) => left: 0
+    send(params,0)
+  end
 end
 generator.build_particle(:clear)
 generator.build_particle(:path)
@@ -29,3 +44,6 @@ generator.build_particle(:read) do |file, proc|
     send("#{renderer}_reader", file, &proc)
   end
 end
+
+generator.build_particle(:cursor)
+

data/lib/atome/genesis/genesis.rb

@@ -11,9 +11,9 @@ end
 
 # Genesis method here
 class Atome
-  def build_particle(particle_name, &particle_proc)
+  def build_particle(particle_name,type=:string, &particle_proc)
     # we add the new method to the particle's collection of methods
-    Universe.add_to_particle_list(particle_name)
+    Universe.add_to_particle_list(particle_name, type)
     auto_render_generator(particle_name)
     new_particle(particle_name, &particle_proc)
     additional_particle_methods(particle_name, &particle_proc)
@@ -28,11 +28,11 @@ class Atome
 
   def auto_render_generator(element)
     Universe.renderer_list.each do |render_engine|
-      build_render_method("#{render_engine}_#{element}")
+      build_render("#{render_engine}_#{element}")
     end
   end
 
-  def build_render_method(renderer_name, &method_proc)
+  def build_render(renderer_name, &method_proc)
     new_render_engine(renderer_name, &method_proc)
   end