atome 0.5.3.8.1 → 0.5.4.0.9

data/lib/atome/genesis/sparkle.rb

@@ -18,64 +18,83 @@ end
 # now let's get the default render engine
 default_render = Essentials.default_params[:render_engines]
 
+
+def atome_infos
+  puts "atome version: #{Atome::VERSION}"
+  # puts "application identity: #{Universe.app_identity}"
+  puts "application identity:  #{Atome::aui}"
+  # puts "application mode:  #{Atome.mode}"
+  puts "host framework:  #{$host}"
+  puts "script mode: #{Universe.current_machine}"
+  puts "user: #{Universe.current_user}"
+  puts "server: #{Universe.current_server}"
+end
+
 Universe.current_user = :jeezs
-puts "application identity: #{Universe.app_identity}"
-puts "atome version: #{Atome::VERSION}"
-puts "current host: #{Universe.current_machine}"
-puts "current user: #{Universe.current_user}"
-puts "current server: #{Universe.current_server}"
+
+
+atome_infos
 
 Atome.new(
-  { element: { renderers: [], id: :eDen, type: :element,
-               parents: [], children: [] } }
+  { element: { renderers: [], id: :eDen, type: :element , tag: {system: true}} }
 )
 
 Atome.new(
-  { element: { renderers: [], id: :user_view, type: :element,
-               parents: [:eDen], children: [] } }
+  { element: { renderers: [], id: :user_view, type: :element, tag: {system: true},
+attach: [:eDen] } }
 )
 
 # color creation
 Atome.new(
-  { color: { renderers: default_render, id: :view_color, type: :color,
+  { color: { renderers: default_render, id: :view_color, type: :color,tag: ({persistent: true}),
              red: 0.15, green: 0.15, blue: 0.15, alpha: 1 } }
 )
 
 Atome.new(
-  { color: { renderers: default_render, id: :shape_color, type: :color,
+  { color: { renderers: default_render, id: :shape_color, type: :color,tag: ({persistent: true}),
              red: 0.4, green: 0.4, blue: 0.4, alpha: 1 } }
 )
 
 Atome.new(
-  { color: { renderers: default_render, id: :box_color, type: :color,
+  { color: { renderers: default_render, id: :box_color, type: :color,tag: ({persistent: true}),
              red: 0.5, green: 0.5, blue: 0.5, alpha: 1 } }
 )
 
 Atome.new(
-  { color: { renderers: default_render, id: :text_color, type: :color,
+  { color: { renderers: default_render, id: :text_color, type: :color,tag: ({persistent: true}),
              red: 0.3, green: 0.3, blue: 0.3, alpha: 1 } }
 )
 
 Atome.new(
-  { color: { renderers: default_render, id: :circle_color, type: :color,
+  { color: { renderers: default_render, id: :circle_color, type: :color,tag: ({persistent: true}),
              red: 0.6, green: 0.6, blue: 0.6, alpha: 1 } }
 )
 
 Atome.new(
-  { color: { renderers: default_render, id: :matrix_color, type: :color,
+
+  { color: { renderers: default_render, id: :matrix_color, type: :color,tag: ({persistent: true}),
              left: 0, top: 0, red: 0.7, green: 0.7, blue: 0.7, alpha: 1, diffusion: :linear } }
 )
 
 # system object creation
 # the black_matter is used to store un materialized atomes
 Atome.new(
-  { shape: { renderers: default_render, id: :black_matter, type: :shape, parents: [:user_view], children: [],
-             left: 0, right: 0, top: 0, bottom: 0, width: 0, height: 0, overflow: :hidden
+  { shape: { renderers: default_render, id: :black_matter, type: :shape, attach: [:user_view],
+             left: 0, right: 0, top: 0, bottom: 0, width: 0, height: 0, overflow: :hidden, tag: {system: true}
   } })
+
 # view port
 Atome.new(
-  { shape: { renderers: default_render, id: :view, type: :shape, parents: [:user_view], children: [],
-             attached: [:view_color], left: 0, right: 0, top: 0, bottom: 0, width: :auto, height: :auto, overflow: :auto
+  { shape: { renderers: default_render, id: :view, type: :shape, attach: [:user_view], tag: {system: true},
+             attached: :view_color, left: 0, right: 0, top: 0, bottom: 0, width: :auto, height: :auto, overflow: :auto,
+  }
+  }
+)
+
+#unreal port
+Atome.new(
+  { shape: { renderers: default_render, id: :intuition, type: :shape, attach: [:user_view], tag: {system: true},
+             left: 0,  top: 0, width: 0, height: 0, overflow: :visible,
   }
   }
 )

data/lib/atome/helpers/callbacks.rb

@@ -5,6 +5,7 @@ class Atome
   private
 
   attr_accessor :drag_start_proc, :drag_move_proc, :drag_end_proc,
+                :drop_action_proc,:over_action_proc,
                 :play_start_proc, :play_active_proc, :play_end_proc,
                 :animation_start_proc, :animation_active_proc, :animation_stop_proc
 
@@ -15,7 +16,10 @@ class Atome
   end
 
   def read_callback(file, proc)
-    instance_exec(file, &proc) if proc.is_a?(Proc)
+    file_content=file.split('</head><body>')[1].split('</body></html>')[0]
+    # FIXME : found why '> is converted to &gt;'
+    file_content=file_content.gsub("&gt;", ">")
+    instance_exec(file_content, &proc) if proc.is_a?(Proc)
   end
 
   def time_callback(current_time, markers)
@@ -29,6 +33,7 @@ class Atome
     end
   end
 
+  # drag callbacks
   def drag_start_callback(page_x, page_y, left_val, top_val)
     @atome[:left] = left_val
     @atome[:top] = top_val
@@ -46,10 +51,51 @@ class Atome
   def drag_end_callback(page_x, page_y, left_val, top_val)
     @atome[:left] = left_val
     @atome[:top] = top_val
+    # alert :loo
+    # #now we rest the position
+    # self.left(left_val)
+    # self.top(top_val)
     proc = @drag_end_proc
     instance_exec({ pageX: page_x, pageY: page_y, left: left_val, top: top_val }, &proc) if proc.is_a?(Proc)
   end
 
+  # drop callbacks
+  def drop_action_callback( data_found, _full_event)
+    proc = @drop_action_proc
+    instance_exec(data_found, &proc) if proc.is_a?(Proc)
+  end
+
+  # def over_action_callback( data_found, _full_event)
+  #   proc = @enter_action_proc
+  #   instance_exec(data_found, &proc) if proc.is_a?(Proc)
+  # end
+
+  # drop callbacks
+  def enter_action_callback( data_found, _full_event)
+    proc = @enter_action_proc
+    instance_exec( data_found,&proc) if proc.is_a?(Proc)
+  end
+
+  def leave_action_callback(data_found)
+    proc = @leave_action_proc
+    instance_exec( data_found,&proc) if proc.is_a?(Proc)
+  end
+
+
+  # def drag_move_callback(page_x, page_y, left_val, top_val)
+  #   proc = @drag_move_proc
+  #   @atome[:left] = left_val
+  #   @atome[:top] = top_val
+  #   instance_exec({ pageX: page_x, pageY: page_y, left: left_val, top: top_val }, &proc) if proc.is_a?(Proc)
+  # end
+  #
+  # def drag_end_callback(page_x, page_y, left_val, top_val)
+  #   @atome[:left] = left_val
+  #   @atome[:top] = top_val
+  #   proc = @drag_end_proc
+  #   instance_exec({ pageX: page_x, pageY: page_y, left: left_val, top: top_val }, &proc) if proc.is_a?(Proc)
+  # end
+
   # sort callbacks
   def sort_callback(atome)
     sort_proc = @sort_proc

data/lib/atome/helpers/essentials.rb

@@ -3,28 +3,32 @@
 # use to sanitize and secure user input
 module Essentials
   @default_params = {
+    # Warning :  type must be define first
     render_engines: [:browser],
-    collector: { type: :element, renderers: [], children: [], parents: [:black_matter] },
-    animation: { type: :animation, children: [] , parents: [:black_matter]},
-    element: { type: :element, renderers: [], children: [] , parents: [:black_matter]},
-    matrix: { renderers: [], id: '', type: :shape, width: 99, height: 99,
-              attached: [:matrix_color], children: [],
-              left: 100, top: 100, clones: [], preset: :matrix, parents: [:view] },
-    box: { renderers: [], id: '', type: :shape,  width: 99, height: 99,
-           attached: [:box_color], children: [], parents: [:view],
+    # collector: { type: :element, attach: [:black_matter] },
+    image: { type: :image, attach: [:view] },
+    web: { type: :web, attach: [:view] },
+    video: { type: :video, attach: [:view] },
+    animation: { type: :animation,  attach: [:black_matter] },
+    element: { type: :element, renderers: [], attach: [:black_matter] },
+    matrix: { type: :shape, width: 99, height: 99,
+              attached: :matrix_color,
+              left: 100, top: 100, clones: [], preset: :matrix, attach: [:view] },
+    box: { type: :shape, width: 99, height: 99,
+           attached: :box_color, attach: [:view],
            left: 100, top: 100, clones: [], preset: :box },
-    circle: { renderers: [], id: '', type: :shape,  width: 99, height: 99, smooth: '100%',
-              attached: [:circle_color], children: [], parents: [:view],
+    circle: { type: :shape, width: 99, height: 99, smooth: '100%',
+              attached: :circle_color, attach: [:view],
               left: 100, top: 100, clones: [], preset: :circle },
-    shape: { renderers: [], id: '', type: :shape,  width: 99, height: 99,
-             attached: [:shape_color], children: [], parents: [:view],
+    shape: { type: :shape, width: 99, height: 99,
+             attached: :shape_color, attach: [:view],
              left: 100, top: 100, clones: [] },
-    text: { renderers: [], id: '', type: :text, visual: { size: 25 },
-            attached: [:text_color], children: [], parents: [:view],
+    text: { type: :text, visual: { size: 25 },
+            attached: :text_color, attach: [:view],
             data: 'this is a text sample', width: 199, height: 33, clones: [] },
-    drm: { type: :drm,parents: [:black_matter] },
-    shadow: {parents: [:black_matter]},
-    color: {parents: [:black_matter]}
+    drm: { type: :drm, attach: [:black_matter] },
+    shadow: { type: :shadow, attach: [:black_matter] },
+    color: {  type: :color,attach: [:black_matter], red: 0, green: 0, blue: 0, alpha: 1  }
   }
 
   def self.default_params
@@ -32,7 +36,6 @@ module Essentials
   end
 
   def self.new_default_params(new_default)
-    # puts "=====+====> #{new_default}, #{new_default.class}"
     @default_params.merge!(new_default)
   end
 

data/lib/atome/helpers/sanitizer.rb

@@ -10,14 +10,4 @@ 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_parents_and_renderers
-    if @atome
-      parent_found = [@atome[:id]]
-      render_found = @atome[:renderers]
-    else
-      parent_found = []
-      render_found = Essentials.default_params[:render_engines]
-    end
-    { parent: parent_found, renderers: render_found }
-  end
 end

data/lib/atome/helpers/utilities.rb

@@ -4,9 +4,40 @@
 class Atome
   private
 
+  # local server messaging
+  def self.controller_sender(message)
+    return if $host == :browser
+
+    json_msg = message.to_json
+    atome_js.JS.controller_sender(json_msg)
+
+  end
+
+  def response_listener(hashed_msg)
+    js_action = hashed_msg.JS[:action]
+    js_body = hashed_msg.JS[:body]
+    send(js_action, js_body)
+  end
+
+  def self.controller_listener
+
+    return if $host == :browser
+
+    atome_js.JS.controller_listener()
+
+  end
+
+  # def self.mode=(val)
+  #   @atome_mode=val
+  # end
+  #
+  # def self.mode
+  #   "@atome_mode"
+  # end
+
   def collapse
     @atome.each do |element, value|
-      send(element, value) unless element == :type
+      send(element, value)
     end
   end
 
@@ -14,22 +45,21 @@ class Atome
     true
   end
 
-  def sanitize(element, params,&user_proc)
+  def sanitize(element, params, &user_proc)
     bloc_found = Universe.get_sanitizer_method(element)
-    params = instance_exec(params,user_proc, &bloc_found) if bloc_found.is_a?(Proc)
+    params = instance_exec(params, user_proc, &bloc_found) if bloc_found.is_a?(Proc)
     params
   end
 
-
   def history(property, value)
     "historize : #{property} #{value}"
   end
 
   def broadcasting(element)
-    params=instance_variable_get("@#{element}")
+    params = instance_variable_get("@#{element}")
     @broadcast.each_value do |particle_monitored|
       if particle_monitored[:particles].include?(element)
-        code_found=particle_monitored[:code]
+        code_found = particle_monitored[:code]
         instance_exec(self, element, params, &code_found) if code_found.is_a?(Proc)
       end
     end
@@ -37,14 +67,14 @@ class Atome
 
   public
 
-  def monitor(params=nil, &proc_monitoring)
+  def monitor(params = nil, &proc_monitoring)
     if params
-      monitoring=atome[:monitor] ||= {}
+      monitoring = atome[:monitor] ||= {}
       params[:atomes].each do |atome_id|
         target_broadcaster = grab(atome_id).instance_variable_get('@broadcast')
         monitor_id = params[:id] || "monitor#{target_broadcaster.length}"
-        monitoring[monitor_id]=params.merge({code: proc_monitoring})
-        target_broadcaster[monitor_id] = { particles: params[:particles], code:  proc_monitoring }
+        monitoring[monitor_id] = params.merge({ code: proc_monitoring })
+        target_broadcaster[monitor_id] = { particles: params[:particles], code: proc_monitoring }
       end
     else
       atome[:monitor]
@@ -59,7 +89,6 @@ class Atome
     instance_variable_set("@#{element}_code", user_proc)
   end
 
-
   def particles(particles_found = nil)
     if particles_found
       particles_found.each do |particle_found, value_found|
@@ -71,11 +100,28 @@ class Atome
   end
 
   def <<(particle)
-    value = particle.value
-    real_atome[property] << value
+
+    real_atome[property] << particle
+  end
+
+  def add_to_integer(_atome_found, _particle_found, &_user_proc)
+    puts "there's no interest to add anything to an integer!"
+  end
+
+  def add_to_float(_atome_found, _particle_found, &_user_proc)
+    puts "there's no interest to add anything to an integer!"
+  end
+
+  def add_to_bignum(_atome_found, _particle_found, &_user_proc)
+    puts "there's no interest to add anything to an integer!"
+  end
+
+  def add_to_string(_atome_found, _particle_found, &_user_proc)
+    puts "there's no interest to add anything to an string!"
   end
 
   def add_to_hash(particle, values, &user_proc)
+    @atome[:add][particle] = true
     # we update  the holder of any new particle if user pass a bloc
     store_code_bloc(particle, &user_proc) if user_proc
     values.each do |value_id, value|
@@ -84,36 +130,53 @@ class Atome
   end
 
   def add_to_array(particle, value, &_user_proc)
+    @atome[:add][particle] = true
     # we update  the holder of any new particle if user pass a bloc
     @atome[particle] << value
   end
 
-  def add_to_atome(atome_found, particle_found, &user_proc)
-    puts "we add : #{particle_found} to #{send(atome_found)} "
-    send(atome_found,particle_found,:adder, &user_proc)
+  def add_to_atome(atome_type, particle_found, &user_proc)
+    # puts "-----> atome_type : #{atome_type}, particle_found : #{particle_found}"
+    # @atome[:add] = [] unless @atome[:add]
+    @atome[:add][atome_type] = particle_found
+    send(atome_type, particle_found, &user_proc)
   end
 
   def add(particles, &user_proc)
+
+    @atome[:add] = {} unless @atome[:add]
     particles.each do |particle, value|
       particle_type = Universe.particle_list[particle] || 'atome'
       send("add_to_#{particle_type}", particle, value, &user_proc)
+      # now we remove systematically the added hash so next particle won't be automatically added
+      @atome[:add].delete(particle)
     end
   end
 
+  def substract(_particles, &_user_proc)
+    # TODO : write code here to remove add elements"
+    puts "write code here to remove add elements"
+    # @atome[:add]=:poi
+    # particles.each do |particle, value|
+    #   particle_type = Universe.particle_list[particle] || 'atome'
+    #   puts "<<<<<< this the place to b ....>>>>>>#{particles} #{particle_type}"
+    #   send("add_to_#{particle_type}", particle, value, &user_proc)
+    # end
+  end
+
   def refresh
     collapse
   end
 
-  def collector(params = {}, &bloc)
-    atome_type = :collector
-    generated_render = params[:renderers] || []
-    generated_id = params[:id] || identity_generator(atome_type)
-
-    generated_parents = params[:parents] || [id.value]
-    generated_children = params[:children] || []
-    params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
-    Batch.new({ atome_type => params }, &bloc)
-  end
+  # def collector(params = {}, &bloc)
+  #   atome_type = :collector
+  #   # generated_render = params[:renderers] || []
+  #   # generated_id = params[:id] || identity_generator(atome_type)
+  #   #
+  #   # generated_parents = params[:parents] || [id]
+  #   params = atome_common(atome_type, params)
+  #   Batch.new({ atome_type => params }, &bloc)
+  # end
 
   def each(&proc)
     value.each do |val|
@@ -122,35 +185,34 @@ class Atome
   end
 
   def include?(value)
-    self.value.include?(value)
+    self.include?(value)
   end
 
-
-
-  def each_with_index(*args)
-    self.value.each_with_index do |val, index|
-      yield(val, index)
-    end
+  def each_with_index(*args, &block)
+    value.each_with_index(&block)
   end
 
   def [](range)
-    if value[range].class == Atome
-      return value[range]
-    elsif value[range].class == Array
-      collector_object = Object.collector({})
-      collected_atomes = []
-      value[range].each do |atome_found|
-        collected_atomes << atome_found
-      end
-      collector_object.data(collected_atomes)
-
-      return collector_object
+    if instance_of?(Atome)
+      value[range]
+      # elsif value[range].instance_of?(Atome)
+      #   return value[range]
+    elsif value[range].instance_of?(Array)
+      # collector_object = Object.collector({})
+      # collected_atomes = []
+      # value[range].each do |atome_found|
+      #   collected_atomes << atome_found
+      # end
+      # collector_object.data(collected_atomes)
+      Batch.new(value[range])
+      # return collector_object
     end
 
   end
+
   def []=(params, value)
     # TODO : it may miss some code, see above
-    self.value[params] = value
+    self[params] = value
   end
 
   def set(params)
@@ -169,4 +231,40 @@ class Atome
     end
   end
 
+  def materials
+    # TODO: the code below need a rewrite, we must find a new algorithm to avoid all those conditions
+    images_found = atome[:image] || []
+    videos_found = atome[:video] || []
+    shapes_found = atome[:shape] || []
+    web_found = atome[:web] || []
+    texts_found = atome[:text] || []
+    images_found.concat(videos_found).concat(shapes_found).concat(web_found).concat(texts_found)
+  end
+
+
+  def physical
+    types=[:text, :image, :video, :shape, :web]
+    atomes_found=[]
+    types.each do |type|
+      ids_found = self.send(type)
+      next unless ids_found
+
+      ids_found.each do |id_found|
+        atomes_found << id_found
+      end
+    end
+    atomes_found
+  end
+
+  def detach_atome(atome_id_to_detach)
+    atome_to_detach = grab(atome_id_to_detach)
+    # TODO: remove the condition below and find why it try to detach an atome that doesn't exist
+    return unless atome_to_detach
+    atome_type_found = atome_to_detach.atome[:type]
+    atome_id_found = atome_to_detach.atome[:id]
+    @atome[atome_type_found].delete(atome_id_found)
+    @atome[:attached].delete(atome_id_to_detach)
+
+  end
+
 end

data/lib/atome/kernel/batch.rb

@@ -1,49 +1,26 @@
 # frozen_string_literal: true
 
+# this class is used to allow batch treatment
 class Batch
-
   def each(&proc)
-    value.each do |val|
-      instance_exec(val, &proc) if proc.is_a?(Proc)
-    end
-  end
-
-  def id(val = nil)
-    if val
-      @id = val
-    else
-      @id
+    @data.each do |val|
+      atome_found = grab(val)
+      instance_exec(atome_found, &proc) if proc.is_a?(Proc)
     end
   end
 
   def initialize(params)
-    @id = params[:id] || identity_generator(:batch)
-    Universe.add_to_atomes(@id, self)
-    Universe.add_to_atomes(@id, self)
+    @data = params
+    # self
   end
 
-  def dispatch (method, *args, &block)
+  def dispatch(method, args, &block)
     @data.each do |atome_found|
-      atome_found.send(method, *args, &block)
+      args.each do |arg|
+        grab(atome_found).send(method, arg, &block)
+      end
     end
+    # we return self to allow method chaining
+    self
   end
-
-  # TODO:  automatise collector methods creation when creating a new atome type
-  def color(args, &block)
-
-    dispatch(:color, args, &block)
-  end
-
-  def shadow(args, &block)
-    dispatch(:color, args, &block)
-  end
-
-  def method_missing(method, *args, &block)
-    dispatch(method, args, &block)
-  end
-
-  def data(collection)
-    @data = collection
-  end
-
-end
+end

data/lib/atome/kernel/universe.rb

@@ -19,7 +19,9 @@ class Universe
 
     def add_optional_method(method_name, &method_proc)
       # this method is used to add optional methods
+      # puts "3 => #{method_name}"
       instance_variable_get('@options').merge!({ method_name => method_proc })
+      # puts "====> #{instance_variable_get('@options')[method_name]}"
     end
 
     def get_optional_method(method_name)
@@ -54,7 +56,7 @@ class Universe
 
     def app_identity
       # each app hav its own identity, this allow to generate new user identities from th
-      @app_identity = 3
+      @app_identity = 369
       # the identity is define as follow : parentsCreatorID_softwareInstanceID_objetID
       # in this case parents 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

data/lib/atome/presets/atome.rb

@@ -5,39 +5,30 @@
 # TODO: Factorise codes below
 # TODO we must clarified/unified the usage of presets and sanitizer it is not clear
 
-
 class Atome
-  def atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
-    temp_default = Essentials.default_params[atome_type] || {}
-    temp_default[:id] = generated_id
-    temp_default[:parents] = generated_parents
-    temp_default[:clones] = []
-    temp_default[:renderers] = generated_render
-    temp_default[:children] = generated_children.concat(temp_default[:children])
-    temp_default.merge(params)
+  def atome_common(atome_type, params)
+    # TODO : optimise the whole code below and make it rubocop friendly
+    essential_params = Essentials.default_params[atome_type] || {}
+    essential_params[:type] = essential_params[:type] || :element
+    essential_params[:renderers] = essential_params[:renderers] || @atome[:renderers]
+    essential_params[:id] = params[:id] || identity_generator(atome_type)
+    essential_params[:attach] = params[:attach] || [@atome[:id]] || [:view]
+    essential_params.merge(params)
   end
 
   def box(params = {}, &bloc)
-    default_renderer = Essentials.default_params[:render_engines]
     atome_type = :box
-    generated_render = params[:renderers] || default_renderer
-    generated_id = params[:id] || identity_generator(:box)
-    generated_parents = params[:parents] || [id.value]
-    generated_children = params[:children] || []
-
-    params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
-
+    params = atome_common(atome_type, params)
     Atome.new({ atome_type => params }, &bloc)
   end
 
   def circle(params = {}, &bloc)
-    default_renderer = Essentials.default_params[:render_engines]
     atome_type = :circle
-    generated_render = params[:renderers] || default_renderer
-    generated_id = params[:id] || identity_generator(:circle)
-    generated_parents = params[:parents] || [id.value]
-    generated_children = params[:children] || []
-    params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
+    # puts "counter#{Universe.counter}"
+
+    params = atome_common(atome_type, params)
+    # puts "params ==> #{params} : #{Universe.counter}"
+
     Atome.new({ atome_type => params }, &bloc)
   end