atome 0.5.4.1.9 → 0.5.5.6.4

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

@@ -1,67 +1,234 @@
 # frozen_string_literal: true
 
 new({ particle: :touch, type: :hash, store: false })
-new({ post: :touch }) do |params, user_bloc|
-  @touch = {} if @touch == nil
-  @touch[params] = user_bloc
-  # as store for touch is set to false we have to manually save the instance variable
-  store_value(:touch)
+new({ sanitizer: :touch }) do |params, user_bloc|
+  # TODO: factorise code below
+  @touch ||= {}
+  @touch_code ||= {}
+  option = true
+  params = if params.instance_of? Hash
+             @touch_code[params.keys[0]] = user_bloc
+             option = params[params.keys[0]]
+             params.keys[0]
+           else
+             case params
+             when true
+               @touch_code[:tap] = user_bloc
+               :tap
+             when :touch
+               @touch_code[:tap] = user_bloc
+               :tap
+             when :down
+               @touch_code[:down] = user_bloc
+               :down
+             when :up
+               @touch_code[:up] = user_bloc
+               :up
+             when :long
+               @touch_code[:long] = user_bloc
+               :long
+             when :double
+               @touch_code[:double] = user_bloc
+               :double
+             when :remove
+               params
+             when false
+               @touch_code[:remove] = user_bloc
+               :remove
+             else
+               @touch_code[:tap] = user_bloc
+               :tap
+             end
+           end
+  @touch[params] = option
+  params
+
 end
+new({ particle: :play, store: false })
+new({ sanitizer: :play }) do |params, user_bloc|
+  @play ||= {}
+  @play_code ||= {}
+  option = true
+  params = if params.instance_of? Hash
+             @play_code[params.keys[0]] = user_bloc
+             option = params[params.keys[0]]
+             params.keys[0]
+           else
+             case params
+             when true
+               @play_code[:play] = user_bloc
+               :play
+             when :stop
+               @play_code[:stop] = user_bloc
+               :stop
+             when :play
+               @play_code[:play] = user_bloc
+               :play
+             when :pause
+               @play_code[:pause] = user_bloc
+               :pause
+             else
+               @play_code[:play] = user_bloc
+               option = params
+               :play
+             end
 
-new({ particle: :play }) do
-  @atome[:pause] = :false
+           end
+  @play[params] = option
+
+  params
 end
+new({ particle: :pause })
 new({ particle: :time })
-new({ particle: :pause }) do
-  @atome[:play] = :false
+new({ particle: :on, store: false })
+new({ sanitizer: :on }) do |params, user_bloc|
+  @on ||= {}
+  @on_code ||= {}
+
+  option = {}
+  params = if params.instance_of? Hash
+             @on_code[:view_resize] = user_bloc
+             option = params[params.keys[0]]
+             :resize
+           else
+             case params
+             when true
+               @on_code[:view_resize] = user_bloc
+               :resize
+             when :remove
+
+               :remove
+             else
+               @on_code[:view_resize] = user_bloc
+               option = params
+               :resize
+             end
+           end
+  @on[params] = option
+  params
 end
-new({ particle: :on })
 new({ particle: :fullscreen })
 new({ particle: :mute })
 new({ particle: :drag, store: false })
+new({ sanitizer: :drag }) do |params, user_bloc|
+  @drag ||= {}
+  @drag_code ||= {}
+  option = true
+  params = if params.instance_of? Hash
+             @drag_code[params.keys[0]] = user_bloc
+             option = params[params.keys[0]]
+             params.keys[0]
+           else
+             case params
+             when true
+               @drag_code[:move] = user_bloc
+               :move
+             when :move
+               @drag_code[:move] = user_bloc
+               :move
+             when :drag
+               @drag_code[:move] = user_bloc
+               :move
+             when :clone
+               @drag_code[:clone] = user_bloc
+               :clone
+             when :start
+               @drag_code[:start] = user_bloc
+               :start
+             when :stop
+               @drag_code[:end] = user_bloc
+               :end
+             when :end
+               @drag_code[:end] = user_bloc
+               :end
+             when :locked
+               @drag_code[:locked] = user_bloc
+               :locked
+             when false
+               @drag_code[:remove] = user_bloc
+               :remove
+             else
+               @drag_code[:move] = user_bloc
+               :move
+             end
 
-new({ sanitizer: :drag }) do |params, proc|
-  params = { move: true } if params == true
-  params = { end: proc } if params == :end
-  params = { start: proc } if params == :start
+           end
+  @drag[params] = option
   params
 end
+new({ particle: :drop, store: false })
+new({ sanitizer: :drop }) do |params, user_bloc|
+  @drop ||= {}
+  @drop_code ||= {}
+  option = true
+  params = if params.instance_of? Hash
+             @drop_code[params.keys[0]] = user_bloc
+             option = params[params.keys[0]]
+             params.keys[0]
+           else
+             case params
+             when true
+               @drop_code[:dropped] = user_bloc
+               :dropped
+             when :enter
+               @drop_code[:enter] = user_bloc
+               :enter
+             when :activate
+               @drop_code[:activate] = user_bloc
+               :activate
+             when :deactivate
+               @drop_code[:deactivate] = user_bloc
+               :deactivate
+             when :leave
+               @drop_code[:leave] = user_bloc
+               :leave
+             else
+               @drop_code[:dropped] = user_bloc
+               :dropped
+             end
 
-new({ post: :drag }) do |params|
-  # puts  "params is : > #{params}"
-  @drag = {} if @drag == nil
-  # @drag[params] = user_bloc
-  params.each do |k, v|
-    @drag[k] = v
-  end
-  # @drag=params
-  # as store for touch is set to false we have to manually save the instance variable
-  store_value(:drag)
-end
-
-# @touch[params] = user_bloc
-
-new ({ particle: :drop })
-
-new ({ sanitizer: :drop }) do |params|
-  params = { action: true } if params == true
+           end
+  @drop[params] = option
   params
 end
+new({ particle: :over, type: :hash, store: false })
+new({ sanitizer: :over }) do |params, user_bloc|
+
+  #  TODO: factorise code below
+  @over ||= {}
+  @over_code ||= {}
+  option = true
+  params = if params.instance_of? Hash
 
-new ({ particle: :over })
+             @over_code[params.keys[0]] = user_bloc
+             option = params[params.keys[0]]
+             params.keys[0]
+           else
+             case params
+             when true
+               @over_code[:over] = user_bloc
+               :over
+             when :over
+               @over_code[:over] = user_bloc
+               :over
+             when :enter
+               @over_code[:enter] = user_bloc
+               :enter
+             when :leave
+               @over_code[:leave] = user_bloc
+               :leave
+               # when false
+               #   false
+             else
+               :over
+             end
 
-new ({ sanitizer: :over }) do |params, user_proc|
+           end
 
-  params = :enter if params == true
-  case params
-  when :enter
-    @enter_action_proc = user_proc
-  when :leave
-    @leave_action_proc = user_proc
-  end
+    @over[params] = option
   params
-end
 
+end
 new({ particle: :sort }) do |_value, sort_proc|
   @sort_proc = sort_proc
 end
@@ -83,5 +250,74 @@ new({ particle: :stiffness })
 new({ particle: :velocity })
 new({ particle: :repeat })
 new({ particle: :ease })
-new({ particle: :unbind })
+new(particle: :keyboard, type: :hash, store: false)
+new({ sanitizer: :keyboard }) do |params, user_bloc|
+  @keyboard ||= {}
+  @keyboard_code ||= {}
+
+  option = {}
+  params = if params.instance_of? Hash
+             # @keyboard_code[:keyboard] = user_bloc
+             option = params[params.keys[0]]
+             :remove
+           else
+             case params
+             when true
+               @keyboard_code[:press] = user_bloc
+               :press
+             when :down
+               @keyboard_code[:down] = user_bloc
+               :down
+             when :up
+               @keyboard_code[:up] = user_bloc
+               :up
+             when :press
+               @keyboard_code[:press] = user_bloc
+               :press
+             when :remove
+               @keyboard_code[:remove] = user_bloc
+               :remove
+             else
+               @keyboard_code[:press] = user_bloc
+               option = params
+               :press
+             end
+
+           end
+  @keyboard[params] = option
+
+  params
+end
+new({ particle: :resize, store: false  })
+new({ sanitizer: :resize }) do |params, user_bloc|
+  @resize ||= { }
+  @resize_code ||= {}
 
+  option = {min: { width: 10, height: 10 }, max: { width: 3000, height: 3000 }}
+  params = if params.instance_of? Hash
+             @resize_code[:resize] = user_bloc
+             option = params[params.keys[0]]
+             :resize
+           else
+             case params
+             when true
+               @resize_code[:resize] = user_bloc
+               :resize
+             when :remove
+               :remove
+             else
+               @resize_code[:resize] = user_bloc
+               option = params
+               :resize
+             end
+           end
+  @resize[params] = option
+
+  params
+end
+new({ particle: :overflow }) do |params, bloc|
+  @overflow_code ||= {}
+  instance_variable_get('@overflow_code')[:overflow] = bloc
+  params
+
+end

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

@@ -3,14 +3,5 @@
 new({particle: :width })
 new({particle: :height })
 new({particle: :size }) do |params|
-  atome_width = atome[:width]
-  atome_height = atome[:height]
-  aspect_ratio = atome_width / atome_height
-  if atome_width > atome_height
-    width(params)
-    height(params / aspect_ratio)
-  else
-    width(params * aspect_ratio)
-    height(params)
-  end
+  params
 end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+def detach_child(child)
+  return unless child.attach
+
+    parent = grab(child.attach)
+    parent.attached.delete(@id)
+  
+end
+
+def detach_from_parent(parent_found, child_found)
+  child_found.attach(false)
+end
+
+def attachment_common(child_id, parents_id, direction, &user_proc)
+  parent_found = grab(parents_id)
+  if direction == :attach
+    if parent_found
+      parent_found.attached ||= []
+      parent_found.attached.push(@id) unless parent_found.attached.include?(@id)
+      detach_child(self)
+      render(:attach, parents_id, &user_proc)
+    else
+      # we remove the current id  from parent
+      grab(attach).attached.delete(@id)
+    end
+  else
+    child_found = grab(child_id)
+    detach_from_parent(parent_found, child_found)
+    child_found.render(:attach, parents_id, &user_proc)
+  end
+end
+
+new({ particle: :attach, render: false }) do |parents_id, &user_proc|
+  attachment_common(@id, parents_id, :attach, &user_proc)
+  parents_id
+end
+
+new({ particle: :attached, render: false }) do |children_ids, &user_proc|
+  children_ids = [children_ids] unless children_ids.instance_of?(Array)
+  parents_id = @id
+  children_ids.each do |children_id|
+    attachment_common(children_id, parents_id, :attached, &user_proc)
+  end
+  children_ids
+end
+
+new({ sanitizer: :attached }) do |children_ids|
+  children_ids
+end
+
+new({ particle: :apply, render: false, store: false }) do |parents_ids, &user_proc|
+  # TODO: optimize the 2 lines below:
+  @apply ||= []
+  parents_ids = [parents_ids] unless parents_ids.instance_of?(Array)
+  parents_ids.each do |parent_id|
+    @apply.delete(parent_id)
+    @apply << parent_id
+  end
+  parents_ids = @apply
+  children_ids = [id]
+  parents_ids.each do |parent_id|
+    parent_found = grab(parent_id)
+    parent_affect = parent_found.instance_variable_get('@affect')
+    parent_found.instance_variable_set('@affect', []) unless parent_affect.instance_of? Array
+    affect_element = parent_found.instance_variable_get('@affect')
+    children_ids.each do |child_id|
+      # affect_element << child_id unless affect_element.include?(child_id)
+      affect_element.delete(child_id)
+      # affect_element.push(child_id)
+      affect_element << child_id
+      child_found = grab(child_id)
+      child_found&.render(:apply, parent_found, &user_proc)
+    end
+  end
+  @apply = parents_ids
+
+  parents_ids
+end
+
+new({ particle: :affect, render: false }) do |children_ids, &user_proc|
+  children_ids = [children_ids] unless children_ids.instance_of? Array
+  children_ids.each do |child_id|
+    child_found = grab(child_id)
+    child_found&.apply([id], &user_proc)
+  end
+  children_ids
+end
+
+new({ particle: :detached, store: false }) # unfastened
+new({ sanitizer: :detached }) do |values|
+  # unfastened
+  if values.instance_of? Array
+    values.each do |value|
+      detach_atome(value)
+    end
+  else
+    detach_atome(values)
+    # we sanitize the values so it always return an array to the renderer
+    values = [values]
+  end
+  values
+end
+new({ particle: :collect })

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

@@ -1,81 +1,13 @@
 # frozen_string_literal: true
 
-new({ particle: :attach })
-new({ sanitizer: :attach }) do |parents_ids|
-  # puts "=> attach it! : #{parents_ids} <="
-
-  # parents_ids = parents_ids if parents_ids.instance_of? Atome
-  parents_ids = [parents_ids] unless parents_ids.instance_of?(Array)
-  parents_ids.each do |parents_id|
-    # parents_id = parents_id if parents_id.instance_of? Atome
-    parents_found = grab(parents_id)
-    # TODO : factorise the code below
-    current_type = atome[:type]
-    parents_found.atome[current_type] = [] unless parents_found.atome[current_type]
-
-    # the condition below is needed when user passed a hash instead of the id of the child cf :
-    parent_type_container = if parents_found.atome[current_type].instance_of? Array
-                              parents_found.atome[current_type]
-                            else
-                              [parents_found.atome[current_type][:id]]
-                            end
-    # here we add the child into it's parents type container
-    parent_type_container << atome[:id]
-    # TODO : factorise the code above
-    parents_found.atome[:attached] = [] unless parents_found.atome[:attached]
-    parents_found.atome[:attached] << atome[:id]
-  end
-  parents_ids
-end
-
-new({ particle: :attached })
-new({ sanitizer: :attached }) do |children_ids|
-  # puts "=> attached now! : #{children_ids}<="
-  # children_ids = children_ids if children_ids.instance_of? Atome
-  children_ids = [children_ids] unless children_ids.instance_of?(Array)
-  children_ids.each do |child_id|
-    # child_id = child_id if child_id.instance_of? Atome
-    child_found = grab(child_id)
-    parents_found = @atome[:id]
-    # TODO : factorise the code below
-    child_found_type = child_found.type
-    @atome[child_found_type] = [] unless @atome[child_found_type]
-
-    # the condition below is needed when user passed a hash instead of the id of the child cf :
-    # circle(color: {red: 0, green: 1}) instead of color({id: :the_col}); circle(color: [:the_col])
-    child_type_container = if @atome[child_found_type].instance_of? Array
-                             @atome[child_found_type]
-                           else
-                             [@atome[child_found_type][:id]]
-                           end
-    child_type_container << child_id
-    # TODO : factorise the code above
-    child_found.atome[:attach] = [parents_found]
-  end
-end
-
-new({ particle: :detached, store: false })
-new({ sanitizer: :detached }) do |values|
-  if values.instance_of? Array
-    values.each do |value|
-      detach_atome(value)
-    end
-  else
-    detach_atome(values)
-    # we sanitize the values so it always return an array to the renderer
-    values = [values]
-  end
-  values
-end
-
-
-
 new({ particle: :real })
 new({ particle: :type })
 new({ particle: :id })
 new({ sanitizer: :id }) do |params|
-  if @atome[:id] != params
-    Universe.update_atome_id(params, self, @atome[:id])
+  # first we sanitize the the id below
+  params = params.to_sym
+  if @id.to_sym != params
+    Universe.update_atome_id(params, self, @id)
   else
     Universe.add_to_atomes(params, self)
   end
@@ -83,18 +15,47 @@ new({ sanitizer: :id }) do |params|
 end
 new({ particle: :name })
 new({ particle: :active })
+# new({ particle: :entangled, type: :array })
+# new({ particle: :clones }) do |clones_found|
+#   clones_found.each_with_index do |clone_found, index|
+#     particles_entangled = clone_found[:entangled] ||= []
+#     clone_id = "#{particles[:id]}_clone_#{index}"
+#     original_id = atome[:id]
+#     clone_found[:id] = clone_id
+#     clone_found = particles.merge(clone_found)
+#     clone_found.delete(:html_object)
+#     cloned_atome = Atome.new(clone_found)
+#     monitor({ atomes: [original_id], particles: particles_entangled }) do |_atome, particle, value|
+#       cloned_atome.send(particle, value)
+#     end
+#   end
+# end
+new({ particle: :markup })
+new({particle: :bundle})
+new({ particle: :data })
+
+new({particle: :category, store: false}) do |category_names|
+  category_names=[category_names] unless category_names.instance_of? Array
+  category_names.each do |category_name| 
+    @category << category_name
+  end
+end
+# The selection particle is used by current user to store selected atomes
+new(particle: :selection)
+
+new({ read: :selection }) do |params_get|
+  selector = grab(:selector)
+  selector.collect = params_get
+  selector
+end
 
-new({ particle: :intricate, type: :array })
-new({ particle: :clones }) do |clones_found|
-  clones_found.each_with_index do |clone_found, index|
-    particles_intricated = clone_found[:intricate] ||= []
-    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
+new(particle: :selected) do |params|
+  if params == true
+    grab(Universe.current_user).selection << @id
+  elsif params == false
+    grab(Universe.current_user).selection.delete(@id)
+  else
+    # TODO: for future use
   end
+  params
 end

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

@@ -1,27 +1,7 @@
 # frozen_string_literal: true
 
-# new({ particle: :red }) do
-#   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-#   self
-# end
-# new({ particle: :green }) do
-#   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-#   self
-# end
-# new({ particle: :blue }) do
-#   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-#   self
-# end
-# new({ particle: :alpha }) do
-#   # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-#   self
-# end
-new({ particle: :diffusion }) do
-  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
-  self
-end
-new({ particle: :visual })
-new({ particle: :overflow })
+new({ particle: :component })
+
 new({ particle: :edit })
 new({ particle: :style })
 new({ pre: :style }) do |styles_send, _user_proc|
@@ -31,23 +11,40 @@ new({ pre: :style }) do |styles_send, _user_proc|
 end
 new({ particle: :hide })
 
-new({ 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
-    particle_to_remove_decision(particle_to_remove)
+new({ particle: :remove })
+
+new({ post: :remove }) do |params|
+  # TODO : we have to rethink the removal of atome and particles (with exception like category) and maybe 'use particle type' to handle removal
+  if params.instance_of?(Hash)
+    case params[:all]
+    when :color
+      color.each do |atome_id_found|
+        @apply.delete(atome_id_found)
+      end
+    when :paint
+      paint.each do |atome_id_found|
+        @apply.delete(atome_id_found)
+      end
+    else
+      params.each do |particle, value|
+        case particle
+        when :category
+          @category.delete(value) if particle == :category
+        else
+          puts 'write code'
+        end
+      end
+
+    end
   end
+  params
 end
+
 new({ particle: :classes }) do |value|
   Universe.classes[value] ||= []
   Universe.classes[value] |= [id]
 end
 new({ particle: :remove_classes }) do |value|
-  # Universe.classes.delete(value)
   Universe.classes[value].delete(id)
 end
 new ({ particle: :opacity })
@@ -55,10 +52,10 @@ new ({ particle: :opacity })
 # vector shape
 new({ particle: :definition })
 
-new({ browser: :definition, type: :string })
-
 new({ sanitizer: :definition }) do |params|
   # we remove the unwanted svg tags
   params = params.gsub(/<svg[^>]*>|<\/svg>/, '')
   params
 end
+
+new({ particle: :gradient })