atome 0.5.7.0.3 → 0.3191

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

@@ -1,344 +0,0 @@
-# frozen_string_literal: true
-
-new({ particle: :touch, category: :event, type: :hash, store: false })
-new({ sanitizer: :touch }) do |params, user_bloc|
-  if params
-    # TODO: factorise code below
-    # alert  "touch_code: #{@touch_code}"
-    @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
-  else
-    @touch = false
-    params
-  end
-
-end
-new({ particle: :play, category: :event, type: :boolean, 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
-
-           end
-  @play[params] = option
-
-  params
-end
-new({ particle: :pause, category: :event, type: :boolean })
-new({ particle: :time, category: :event, type: :int })
-new({ particle: :on, category: :event, type: :boolean, 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: :fullscreen, category: :event, type: :boolean })
-new({ particle: :mute, category: :event, type: :boolean })
-new({ particle: :drag, category: :event, type: :boolean, 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
-
-           end
-  @drag[params] = option
-  if params == :remove
-    params = false
-  else
-    @drag[params] = option
-  end
-
-  params
-end
-new({ particle: :drop, category: :event, type: :boolean, 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
-
-           end
-  @drop[params] = option
-  params
-end
-new({ particle: :over, category: :event, 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
-
-             @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
-
-           end
-
-  @over[params] = option
-  params
-
-end
-# new({ particle: :sort }) do |_value, sort_proc|
-#   @sort_proc = sort_proc
-# end
-new({ particle: :targets, category: :event, type: :string })
-new({ particle: :start, category: :event, type: :boolean })
-new({ pre: :start }) do |_value, user_proc|
-  @animation_start_proc = user_proc
-end
-new({ particle: :stop, category: :event, type: :boolean })
-new({ pre: :stop }) do |_value, user_proc|
-  @animation_stop_proc = user_proc
-end
-new({ particle: :begin, category: :event, type: :time })
-new({ particle: :end, category: :event, type: :time })
-new({ particle: :duration, category: :event, type: :int })
-new({ particle: :mass, category: :event, type: :int })
-new({ particle: :damping, category: :event, type: :int })
-new({ particle: :stiffness, category: :event, type: :int })
-new({ particle: :velocity, category: :event, type: :int })
-new({ particle: :repeat, category: :event, type: :boolean })
-new({ particle: :ease, category: :event, type: :boolean })
-new(particle: :keyboard, category: :event, 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, category: :event, type: :boolean, 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, category: :event, type: :boolean }) do |params, bloc|
-  @overflow_code ||= {}
-  instance_variable_get('@overflow_code')[:overflow] = bloc
-  params
-
-end
-new({ particle: :animate, category: :event, type: :hash }) do |params|
-  if params.instance_of? Hash
-    params = { from: 0, to: 300, duration: 1000 }.merge(params)
-  else
-    params = { from: 0, to: 300, duration: 1000 }
-  end
-  html.play_animation(params)
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-new({ particle: :width, category: :geometry, type: :int })
-new({ particle: :height, category: :geometry, type: :int })
-
-new({ particle: :size, category: :geometry, type: :int }) do |params|
-  params = { value: params } unless params.instance_of? Hash
-  params[:recursive] ||= false
-  params[:reference] ||= :x
-  params[:target] ||= :self # :all resize atome + attached +distance between  to the value
-  # self: resize the current atome to current value
-  params[:propagate] ||= :raw # proportional atome children will be resize according
-  # to its parent , raw apply the raw value to the attached atomes
-  if params[:reference] == :x
-    original_width = width
-    width(params[:value])
-    height(height * params[:value] / original_width)
-  else
-    original_height = height
-    height(params[:value])
-    width(width * params[:value] / original_height)
-  end
-
-  if params[:recursive]
-    attached.each do |atome_id|
-      grab(atome_id).size(params)
-    end
-
-  end
-
-end

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

@@ -1,105 +0,0 @@
-# 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(parent_found.id)
-# 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)
-    child_found.attach(parents_id)
-    child_found.render(:attach, parents_id, &user_proc)
-  end
-end
-
-new({ particle: :attach, category: :hierarchy, type: :string, render: false }) do |parents_id, &user_proc|
-  attachment_common(@id, parents_id, :attach, &user_proc)
-  parents_id
-end
-
-new({ particle: :attached, category: :hierarchy, type: :string, 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, category: :hierarchy, type: :string, render: false, store: false }) do |parents_ids, &user_proc|
-  @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.delete(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, category: :hierarchy, type: :string, 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)
-    # FIXME : found why it crash when removing the condition below
-    unless child_found.id == :black_matter
-      child_found.remove({ all: :paint })
-    end
-    child_found.apply([id], &user_proc)
-  end
-
-  children_ids
-end
-
-new({ particle: :detached, category: :hierarchy, type: :string, 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, category: :hierarchy, type: :string })

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

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-new({ particle: :real, category: :identity, type: :string })
-new({ particle: :type, category: :identity, type: :string })
-new({ particle: :id, category: :identity, type: :string })
-new({ sanitizer: :id }) do |params|
-  # first we sanitize the the id below
-
-  params = params.to_sym
-  # we check id is already assign
-  # the condition below is to prevent the creation of multiple unwanted colors with same property and no ID specified
-  #   if @id.to_sym != params
-  #     Universe.update_atome_id(params, self, @id)
-  #   else
-  #     Universe.add_to_atomes(params, self)
-  #   end
-
-
-  # Universe.atomes.each do |_aid,atome_f|
-  #
-  #   if atome_f.id == params
-  #     puts  "===> no for #{params}"
-  #   end
-  #
-  # end
-
-  params
-end
-new({ particle: :name, category: :identity, type: :string })
-new({ particle: :active, category: :identity, type: :boolean })
-# 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, category: :identity, type: :string })
-new({ particle: :bundle, category: :identity, type: :string })
-new({ particle: :data, category: :identity, type: :string })
-
-new({ particle: :category, category: :identity, type: :string, 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, category: :identity, type: :string)
-
-new({ read: :selection }) do |params_get|
-  selector = grab(:selector)
-  selector.collect = params_get
-  selector
-end
-
-new(particle: :selected, category: :identity, type: :boolean) do |params|
-  if params == true
-    border({ thickness: 3, red: 1, green: 1, blue: 1, alpha: 1, pattern: :dotted })
-    border({ thickness: 10,  pattern: :solid, color: :red})
-    grab(Universe.current_user).selection << @id
-  elsif params == false
-    border({alpha: 0, thickness: 0})
-    grab(Universe.current_user).selection.collect.delete(@id)
-  else
-    # TODO: for future use
-  end
-  params
-end
-
-new({ particle: :format, category: :identity, type: :string })
-new({ particle: :alien, category: :identity, type: :string }) # special particel that old alien object
-
-new({ particle: :email, category: :identity, type: :string })

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

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-new({ particle: :component, category: :material, type: :string })
-
-new({ particle: :edit, category: :material, type: :boolean })
-new({ particle: :style, category: :material, type: :string })
-new({ pre: :style }) do |styles_send, _user_proc|
-  styles_send.each do |particle_send, value|
-    send(particle_send, value)
-  end
-end
-new({ particle: :hide, category: :material, type: :boolean })
-
-new({ particle: :remove, category: :property, type: :hash }) do |params|
-  if  params.instance_of? Hash
-    if params[:row]
-      data.delete_at(params[:row])
-
-    elsif params[:column]
-      column = params[:column]
-      data.map do |hash|
-        hash.delete(hash.keys[column]) if hash.keys[column]
-        hash
-      end
-    # elsif params[:all]
-    #   apply.each do |applied_atome|
-    #     if  grab(applied_atome).type.to_sym ==  params[:all].to_sym
-    #       puts "!go"
-    #     end
-    #   end
-      # puts "so_good #{params}"
-      # puts "***> #{apply}"
-    end
-    params
-  else
-
-    params
-  end
-
-
-end
-# new({ particle: :remove, category: :property, type: :hash })
-
-
-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
-    when :shadow
-      shadow.each do |atome_id_found|
-        @apply.delete(atome_id_found)
-      end
-    when :border
-      border.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 to remove atome applied'
-        end
-      end
-
-    end
-  end
-  params
-end
-
-new({ particle: :classes, category: :material, type: :json }) do |value|
-  Universe.classes[value] ||= []
-  Universe.classes[value] |= [id]
-end
-new({ particle: :remove_classes, category: :material, type: :boolean }) do |value|
-  Universe.classes[value].delete(id)
-end
-# new ({ particle: :opacity, category: :material, type: :int })
-
-# vector shape
-new({ particle: :definition, category: :material, type: :string })
-
-new({ sanitizer: :definition }) do |params|
-  # we remove the unwanted svg tags
-  params = params.gsub(/<svg[^>]*>|<\/svg>/, '')
-  params
-end
-
-new({ particle: :gradient, category: :material, type: :int })
-
-new({ particle: :thickness, category: :material, type: :int })
-new({ after: :thickness}) do |params|
-  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
-  a.each do |atome_to_refresh|
-    grab(atome_to_refresh).apply(id)
-  end
-  params
-end
-new({ particle: :pattern, category: :material, type: :string })
-new({ after: :pattern })do |params|
-  a=affect.dup #  FIXME  we have to dup else some items in the array array other duplicated
-  a.each do |atome_to_refresh|
-    grab(atome_to_refresh).apply(id)
-  end
-  params
-end
-# new({ particle: :border, category: :material, type: :int })
-new({particle: :fill, category: :material, type: :array })
-
-new({particle: :opacity, category: :material, type: :int })