atome 0.5.3.8.8 → 0.5.4.0.9

data/lib/atome/extensions/matrix.rb

@@ -1,39 +1,138 @@
 # frozen_string_literal: true
 
 module Matrix
-  def content(items = nil)
-    if items.instance_of?(Array)
-      items.each do |item|
-        content(item)
-      end
-    elsif items.instance_of?(Atome)
-      w_found = items.particles[:width]
-      h_found = items.particles[:height]
-      l_found = items.particles[:left]
-      t_found = items.particles[:top]
-      i_found = items.particles[:id]
-      current_w_found = width
-      current_h_found = height
-      current_l_found = left
-      current_t_found = top
-      @cell_content ||= {}
-      @cell_content[i_found] = { width_ratio: 1, height_ratio: 1, top_ratio: 1, left_ratio: 1 }
-      # alert @cell_content
-      items.parents([id])
+
+  def matrix(params = {}, &bloc)
+
+    params = matrix_sanitizer(params)
+
+    columns_data = if params[:columns]
+                     params.delete(:columns)
+                   else
+                     { count: 4 }
+                   end
+
+    rows_data = if params[:rows]
+                  params.delete(:rows)
+                else
+                  { count: 4 }
+                end
+
+    cells_data = if params[:cells]
+                   params.delete(:cells)
+                 else
+                   { particles: { margin: 9, color: :lightgray } }
+                 end
+    cells_color = cells_data[:particles].delete(:color)
+    # we grab Black matter to avoid coloring the view
+    cells_color_id = grab(:black_matter).color(cells_color).id
+    cells_shadow = cells_data[:particles].delete(:shadow)
+    cells_shadow_id = grab(:black_matter).shadow(cells_shadow).id
+    exceptions_data = params.delete(:exceptions)
+    default_renderer = Essentials.default_params[:render_engines]
+    atome_type = :matrix
+    # generated_render = params[:renderers] || default_renderer
+    # TODO:  maybe change the code below and don't use identity_generator directly!!!
+    generated_id = params[:id] || identity_generator(:matrix)
+    params = atome_common(:matrix, params)
+    the_matrix = Atome.new(atome_type => params, &bloc)
+
+    # the_matrix = Atome.new(matrix: { type: :shape, id: :my_table, renderers: [:browser], parents: [] }, &bloc)
+    # example = Atome.new(code: { type: :code, renderers: [:headless], parents: [], children: [] })
+    # TODO:  use the standard atome creation method (generator.build_atome(:collector)),
+    # TODO suite => For now its impossible to make it draggable because it return the created box not the matrix
+    # get necessary params
+    matrix_id = params[:id]
+    matrix_width = params[:width]
+    matrix_height = params[:height]
+    columns = columns_data[:count]
+    rows = rows_data[:count]
+    margin = cells_data[:particles].delete(:margin)
+    the_matrix.instance_variable_set('@columns', columns)
+    the_matrix.instance_variable_set('@rows', rows)
+    the_matrix.instance_variable_set('@margin', margin)
+    the_matrix.instance_variable_set('@cell_style', cells_data[:particles])
+    the_matrix.instance_variable_set('@matrix_width', matrix_width)
+    the_matrix.instance_variable_set('@matrix_height', matrix_height)
+    the_matrix.instance_variable_set('@cells', [])
+    rows = rows_data[:count]
+    columns = columns_data[:count]
+
+    # exceptions reorganisation
+    if exceptions_data
+      columns_exceptions = exceptions_data[:columns] ||= {}
+      columns_fusion_exceptions = columns_exceptions[:fusion] ||= {}
+      columns_divided_exceptions = columns_exceptions[:divided] ||= {}
+      rows_exceptions = exceptions_data[:rows] ||= {}
+      rows_fusion_exceptions = rows_exceptions[:fusion] ||= {}
+      rows_divided_exceptions = rows_exceptions[:divided] ||= {}
+      exceptions = { columns_fusion: columns_fusion_exceptions,
+                     columns_divided: columns_divided_exceptions,
+                     rows_fusion: rows_fusion_exceptions,
+                     rows_divided: rows_divided_exceptions }
+
     else
-      @cell_content
+      exceptions = {
+        columns_fusion: {},
+        columns_divided: {},
+        rows_fusion: {},
+        rows_divided: {}
+      }
+
     end
+    the_matrix.instance_variable_set('@exceptions', exceptions)
+
+    # let's create the matrix background
+    # cells creation below
+    number_of_cells = rows * columns
+    number_of_cells.times do |index|
+      current_matrix = grab(matrix_id)
+      current_cell_id = "#{matrix_id}_#{index}"
+      current_cell = current_matrix.box({ id: current_cell_id })
+      the_matrix.instance_variable_set('@cell_style', cells_data[:particles])
+      current_matrix.instance_variable_get('@cells') << current_cell_id
+
+        current_cell.attached([cells_shadow_id])
+        current_cell.attached([cells_color_id])
+        apply_style(current_cell, cells_data[:particles])
+
+    end
+    # lets create the columns and rows
+    the_matrix.format_matrix(matrix_id, matrix_width, matrix_height, rows, columns, margin, exceptions)
+
+    the_matrix
   end
 
-  def cells(cell_nb)
-    collector_object = collector({})
-    collected_atomes = []
-    cell_nb.each do |cell_found|
-      atome_found = grab("#{id}_#{cell_found}")
-      collected_atomes << atome_found
+  def matrix_sanitizer(params)
+
+    default_params = {
+
+      left: 33, top: 33, width: 369, height: 369, smooth: 8, color: :gray,
+      columns: { count: 4 },
+      rows: { count: 4 },
+      cells: { particles: { margin: 9, color: :lightgray, smooth: 9, shadow: { blur: 9, left: 3, top: 3 } }
+      }
+    }
+    default_params.merge(params)
+  end
+
+  def cells(cell_nb, &proc)
+    if cell_nb
+      collected_atomes = []
+      cell_nb.each do |cell_found|
+        if cell_found.instance_of?(Integer)
+          cell_found = cells[cell_found]
+          collected_atomes << cell_found
+        else
+          collected_atomes << cell_found
+        end
+      end
+      instance_exec(collected_atomes, &proc) if proc.is_a?(Proc)
+    else
+      instance_exec(@cells, &proc) if proc.is_a?(Proc)
+      @cells
     end
-    collector_object.data(collected_atomes)
-    collector_object
+
   end
 
   def cell(cell_nb)
@@ -64,11 +163,6 @@ module Matrix
     element({ data: cells_found })
   end
 
-  # def ratio(val)
-  #   puts "ratio must be : #{val}"
-  #
-  # end
-
   def fusion(params)
     number_of_cells = @columns * @rows
     if params[:columns]
@@ -78,8 +172,7 @@ module Matrix
         cells_in_column = get_column_or_row(number_of_cells, @columns, column_to_alter, true)
         cells_to_alter = cells_in_column[value[0]..value[1]]
         cells_to_alter.each_with_index do |cell_nb, index|
-          current_cell = grab("#{id.value}_#{cell_nb}")
-          # puts "==> current cell is #{id}"
+          current_cell = grab("#{id}_#{cell_nb}")
           if index.zero?
             current_cell.height(cell_height * cells_to_alter.length + @margin * (cells_to_alter.length - 1))
           else
@@ -95,7 +188,7 @@ module Matrix
         cells_to_alter = cells_in_column[value[0]..value[1]]
 
         cells_to_alter.each_with_index do |cell_nb, index|
-          current_cell = grab("#{id.value}_#{cell_nb}")
+          current_cell = grab("#{id}_#{cell_nb}")
           if index.zero?
             current_cell.width(cell_width * cells_to_alter.length + @margin * (cells_to_alter.length - 1))
           else
@@ -114,10 +207,10 @@ module Matrix
         #  we get the nth first element
         cells_to_alter = cells_in_column.take(value)
         cells_in_column.each_with_index do |cell_nb, index|
-          current_cell = grab("#{id.value}_#{cell_nb}")
+          current_cell = grab("#{id}_#{cell_nb}")
           if cells_to_alter.include?(cell_nb)
             current_cell.height(@matrix_height / value - (@margin + value))
-            current_cell.top(current_cell.height.value * index + @margin * (index + 1))
+            current_cell.top(current_cell.height * index + @margin * (index + 1))
           else
             current_cell.hide(true)
           end
@@ -129,10 +222,10 @@ module Matrix
         #  we get the nth first element
         cells_to_alter = cells_in_row.take(value)
         cells_in_row.each_with_index do |cell_nb, index|
-          current_cell = grab("#{id.value}_#{cell_nb}")
+          current_cell = grab("#{id}_#{cell_nb}")
           if cells_to_alter.include?(cell_nb)
             current_cell.width(@matrix_width / value - @margin - (@margin / value))
-            current_cell.left(current_cell.width.value * index + @margin * (index + 1))
+            current_cell.left(current_cell.width * index + @margin * (index + 1))
           else
             current_cell.hide(true)
           end
@@ -141,11 +234,6 @@ module Matrix
     end
   end
 
-  # def override(params)
-  #   # TODO : allow fixed height ond fixed width when resizing
-  #   puts "should override to allow fixed height or fixed width when resizing #{params}"
-  # end
-
   def first(item, &proc)
     if item[:columns]
       columns(0, &proc)
@@ -173,7 +261,6 @@ module Matrix
         x = (col_index + 1) * margin + col_index * cell_width
         y = (row_index + 1) * margin + row_index * cell_height
         current_cell = grab("#{matrix_id}_#{i}")
-        # puts current_cell
         current_cell.materials.each do |child|
           grab(child).width(cell_width) if grab(child)
           grab(child).height(cell_width) if grab(child)
@@ -187,176 +274,28 @@ module Matrix
     end
 
     # exceptions management
-
-    # number_of_cells = nb_of_rows * nb_of_cols
-    # columns exceptions
-    # return
     return unless exceptions
 
     fusion({ columns: exceptions[:columns_fusion] }) if exceptions[:columns_fusion]
-    # fusion({ rows: exceptions[:rows_fusion] }) if exceptions[:rows_fusion]
-    # divide({ columns: exceptions[:columns_divided] }) if exceptions[:columns_divided]
-    # divide({ rows: exceptions[:rows_divided] }) if exceptions[:rows_divided]
+
   end
 
   def apply_style(current_cell, style)
     current_cell.set(style)
   end
 
-  def matrix_sanitizer(params)
-    default_params = {
-
-      id: :my_table, left: 33, top: 33, width: 369, height: 369, smooth: 8, color: :gray,
-      columns: { count: 4 },
-      rows: { count: 4 },
-      cells: { particles: { margin: 9, color: :lightgray, smooth: 9, shadow: { blur: 9, left: 3, top: 3 } }
-      }
-    }
-    default_params.merge(params)
-  end
-
-  def matrix(params = {}, &bloc)
-    params = matrix_sanitizer(params)
-
-    columns_data = if params[:columns]
-                     params.delete(:columns)
-                   else
-                     { count: 4 }
-                   end
-
-    rows_data = if params[:rows]
-                  params.delete(:rows)
-                else
-                  { count: 4 }
-                end
-
-    cells_data = if params[:cells]
-                   params.delete(:cells)
-                 else
-                   { particles: { margin: 9, color: :lightgray } }
-                 end
-    cells_color = cells_data[:particles].delete(:color)
-    cells_color_id = color(cells_color).id.value
-
-    cells_shadow = cells_data[:particles].delete(:shadow)
-    cells_shadow_id = shadow(cells_shadow).id.value
-
-    exceptions_data = params.delete(:exceptions)
-    default_renderer = Essentials.default_params[:render_engines]
-    atome_type = :matrix
-    # generated_render = params[:renderers] || default_renderer
-    generated_id = params[:id] || identity_generator(:matrix)
-    #
-    # generated_parents = params[:parents] || [id.value]
-    # generated_children = params[:shape] || []
-    # params = atome_common(atome_type,  params)
-    params = atome_common(:matrix, params)
-    # puts "====>#{params} #{params.class}"
-    the_matrix = Atome.new( atome_type => params , &bloc)
-    # the_matrix = Atome.new(matrix: { type: :shape, id: :my_table, renderers: [:browser], parents: [] }, &bloc)
-    # example = Atome.new(code: { type: :code, renderers: [:headless], parents: [], children: [] })
-    # TODO:  use the standard atome creation method (generator.build_atome(:collector)),
-    # TODO suite => For now its impossible to make it draggable because it return the created box not the matrix
-    # get necessary params
-    matrix_id = params[:id]
-    matrix_width = params[:width]
-    matrix_height = params[:height]
-    columns = columns_data[:count]
-    rows = rows_data[:count]
-    margin = cells_data[:particles].delete(:margin)
-    the_matrix.instance_variable_set('@columns', columns)
-    the_matrix.instance_variable_set('@rows', rows)
-    the_matrix.instance_variable_set('@margin', margin)
-    the_matrix.instance_variable_set('@cell_style', cells_data[:particles])
-    the_matrix.instance_variable_set('@matrix_width', matrix_width)
-    the_matrix.instance_variable_set('@matrix_height', matrix_height)
-
-    rows = rows_data[:count]
-    columns = columns_data[:count]
-    # @rows = rows_data[:count]
-    # @columns = columns_data[:count]
-    # @margin = cells_data[:particles].delete(:margin)
-    # @cell_style = cells_data[:particles]
-    # @matrix_width = params[:width]
-    # @matrix_height = params[:height]
-
-    # exceptions reorganisation
-    if exceptions_data
-      columns_exceptions = exceptions_data[:columns] ||= {}
-      columns_fusion_exceptions = columns_exceptions[:fusion] ||= {}
-      columns_divided_exceptions = columns_exceptions[:divided] ||= {}
-      rows_exceptions = exceptions_data[:rows] ||= {}
-      rows_fusion_exceptions = rows_exceptions[:fusion] ||= {}
-      rows_divided_exceptions = rows_exceptions[:divided] ||= {}
-      exceptions = { columns_fusion: columns_fusion_exceptions,
-                     columns_divided: columns_divided_exceptions,
-                     rows_fusion: rows_fusion_exceptions,
-                     rows_divided: rows_divided_exceptions }
-      # @exceptions = {
-      #   columns_fusion: columns_fusion_exceptions,
-      #   columns_divided: columns_divided_exceptions,
-      #   rows_fusion: rows_fusion_exceptions,
-      #   rows_divided: rows_divided_exceptions,
-      # }
-    else
-      exceptions = {
-        columns_fusion: {},
-        columns_divided: {},
-        rows_fusion: {},
-        rows_divided: {}
-      }
-      # @exceptions = {
-      #   columns_fusion: {},
-      #   columns_divided: {},
-      #   rows_fusion: {},
-      #   rows_divided: {},
-      # }
-    end
-    the_matrix.instance_variable_set('@exceptions', exceptions)
-
-    # let's create the matrix background
-    # current_matrix = grab(:view).box({ id: matrix_id })
-    # current_matrix.set(params[:matrix][:particles])
-
-    # cells creation below
-    number_of_cells = rows * columns
-    number_of_cells.times do |index|
-      current_cell = grab(matrix_id).box({ id: "#{matrix_id}_#{index}" })
-      the_matrix.instance_variable_set('@cell_style', cells_data[:particles])
-      current_cell.attached([cells_shadow_id])
-      current_cell.attached([cells_color_id])
-      apply_style(current_cell, cells_data[:particles])
-    end
-    # lets create the columns and rows
-
-    # puts "(#{matrix_id}, #{matrix_width}, #{matrix_height}, #{rows}, #{columns}, #{margin}, #{exceptions})"
-    the_matrix.format_matrix(matrix_id, matrix_width, matrix_height, rows, columns, margin, exceptions)
-
-    the_matrix
-  end
-
   def add_columns(nb)
     prev_nb_of_cells = @columns * @rows
     nb_of_cells_to_adds = nb * @rows
     new_nb_of_cells = prev_nb_of_cells + nb_of_cells_to_adds
     new_nb_of_cells.times do |index|
       if index < prev_nb_of_cells
-        grab("#{id.value}_#{index}").delete(true)
-        # puts index
-        #
+        grab("#{id}_#{index}").delete(true)
       end
       current_cell = box({ id: "#{id}_#{index}" })
       apply_style(current_cell, @cell_style)
     end
     @columns += nb
-    ########## old algo
-    # nb_of_cells_to_adds = nb * @rows
-    # prev_nb_of_cells = @columns * @rows
-    # nb_of_cells_to_adds.times do |index|
-    #   current_cell = self.box({ id: "#{id}_#{prev_nb_of_cells + index}" })
-    #   apply_style(current_cell, @cell_style)
-    # end
-    # @columns = @columns + nb
     format_matrix(id, @matrix_width, @matrix_height, @rows, @columns, @margin, @exceptions)
   end
 
@@ -366,35 +305,24 @@ module Matrix
     new_nb_of_cells = prev_nb_of_cells + nb_of_cells_to_adds
     new_nb_of_cells.times do |index|
       if index < prev_nb_of_cells
-        grab("#{id.value}_#{index}").delete(true)
-        # puts index
-        #
+        grab("#{id}_#{index}").delete(true)
       end
       current_cell = box({ id: "#{id}_#{index}" })
       apply_style(current_cell, @cell_style)
     end
     @rows += nb
-    ########## old algo
-    # nb_of_cells_to_adds = nb * @columns
-    # prev_nb_of_cells = @columns * @rows
-    # nb_of_cells_to_adds.times do |index|
-    #   current_cell = self.box({ id: "#{id}_#{prev_nb_of_cells + index}" })
-    #   apply_style(current_cell, @cell_style)
-    # end
-    # @rows = @rows + nb
     format_matrix(id, @matrix_width, @matrix_height, @rows, @columns, @margin, @exceptions)
   end
 
   def resize(width, height)
     @matrix_width = width
     @matrix_height = height
-    grab(id.value).width(width)
-    grab(id.value).height(height)
+    grab(id).width(width)
+    grab(id).height(height)
     format_matrix(id, @matrix_width, @matrix_height, @rows, @columns, @margin, @exceptions)
   end
 
   def get_column_or_row(length, num_columns, index, is_column)
-    # puts "length: #{length}, #{num_columns} : #{num_columns}, index : #{index}, is_column : #{is_column}"
     # Compute the number of line
     num_rows = length / num_columns
     if is_column

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

@@ -1,136 +1,34 @@
 # frozen_string_literal: true
-
 new({ atome: :color, type: :hash })
 
 new({ sanitizer: :color }) do |params|
   # TODO : when attaching color to a shadow it should colorized it , cf : c.shadow({color: :blue}) should work
-  # parent_found = found_parents_and_renderers[:parent]
-  # if parent_found == [:view]
-  #   parent_found = [:black_matter] if parent_found == [:view]
-  # elsif color.value
-  #   # we delete any previous color if there's one
-  #   #  puts "========= #{@atome[:color]}>We should delete the color now except : #{@atome[:add]} "
-  #   unless @atome[:add] && @atome[:add][:color]
-  #     detached(color.value)
-  #     @atome[:color] = [] # we had the condition because the shadow may exist but
-  #   end
-  # end
-
-
-
-
-  # puts "---> :: #{@atome[:add]}"
-  ## we delete any previous shadow if there's one
-  # if color.value
-  #   puts 'We should delete now'
-  #   attached.value.delete(color.value)
-  #   grab(color.value)&.delete(true) # we had the condition because the color may exist but
-  #   # so it is not sanitized so it has no id
-  # end
-  # parent_found = found_parents_and_renderers[:parent]
-  # parent_found = [:user_view] if parent_found == [:view]
-  # render_found = found_parents_and_renderers[:renderers]
-  # generated_id = params[:id] || identity_generator(:color)
-
-  # default_params = { red: 0, green: 0, blue: 0, alpha: 1 }
   params = create_color_hash(params) unless params.instance_of? Hash
-  # new_params = default_params.merge!(params)
-  # atome[:color] = [new_params[:id]]
-  # test below
-  # atome[:color] = [:poil]
-  # puts "==> #{color.value}"
-  # test above
-  # new_params
-  # atome[:color] << :poil
-  # params={}
-  #
   params
 end
 
-# new({ sanitizer: :color }) do |params|
-#   parent_found = found_parents_and_renderers[:parent]
-#   # puts  "'''''code_below_is_not_executed'''''"
-#   if parent_found == [:black_matter]
-#     alert :stop_get_out_we_are_the_strong_arm_of_the_law
-#   elsif color.value
-#     puts  ">>> Code_below_is_not_executed : #{self}"
-#     # we delete any previous color if there's one
-#     # detached(color.value)
-#     grab(color.value)&.delete(true) # we had the condition because the color may exist but
-#     # so it is not sanitized so it has no id
-#   end
-#
-#   render_found = found_parents_and_renderers[:renderers]
-#   generated_id = params[:id] || identity_generator(:color)
-#
-#   default_params = { renderers: render_found, id: generated_id, type: :color,
-#                      attach: parent_found,
-#                      red: 0, green: 0, blue: 0, alpha: 1 }
-#   params = create_color_hash(params) unless params.instance_of? Hash
-#   new_params = default_params.merge!(params)
-#   new_params
-# end
-
 new({ atome: :image })
 new({ sanitizer: :image }) do |params|
   unless params.instance_of? Hash
     # TODO : we have to convert all image to png or maintain a database with extension
+    # FIXME : temporary patch that add .png to the string if no extension is found
+    if params.split('.').length == 1
+      params = "#{params}.png"
+    end
+
     params = { path: "./medias/images/#{params}" }
   end
-  # default_renderer = Essentials.default_params[:render_engines]
-  # generated_id = params[:id] || identity_generator(:image)
-  #
-  # generated_render = params[:renderers] || default_renderer
-  # generated_parents = params[:attach] || id.value
-  # # TODO : the line below should get the value from default params Essentials
-  # temp_default = { renderers: generated_render, id: generated_id, type: :image, attach: [generated_parents],
-  #                  width: 99, height: 99, path: './medias/images/atome.svg' }
-  # params = temp_default.merge(params)
+  # TODO : the line below should get the value from default params Essentials
   params
 end
 new({ atome: :video })
-# new({ sanitizer: :video }) do |params|
-#   parent_found = found_parents_and_renderers[:parent]
-#   render_found = found_parents_and_renderers[:renderers]
-#   generated_id = params[:id] || identity_generator(:video)
-#
-#   default_params = { renderers: render_found, id: generated_id, type: :video,
-#                      attach: parent_found }
-#   default_params.merge!(params)
-# end
+
 new({ atome: :shadow, type: :hash })
 new({ sanitizer: :shadow }) do |params|
   # TODO : when attaching color to a shadow it should colorised it , cf : c.shadow({color: :blue}) should work
-  # puts "############################{params}###{test}###{test2}##################################"
   params = {} unless params.instance_of? Hash
-  # parent_found = found_parents_and_renderers[:parent]
-  # if parent_found == [:view]
-  #   parent_found = [:black_matter] if parent_found == [:view]
-  # elsif shadow.value
-  #   # we delete any previous color if there's one
-  #   detached(shadow.value)
-  #   grab(shadow.value)&.delete(true) # we had the condition because the shadow may exist but
-  # end
-  ## we delete any previous shadow if there's one
-  # if shadow.value
-  #   attached.value.delete(shadow.value)
-  #   grab(shadow.value)&.delete(true) # we had the condition because the color may exist but
-  #   # so it is not sanitized so it has no id
-  # end
-  # parent_found = found_parents_and_renderers[:parent]
-  # parent_found = [:user_view] if parent_found == [:view]
-  # render_found = found_parents_and_renderers[:renderers]
-  # generated_id = params[:id] || identity_generator(:shadow)
-
-  # default_params = { renderers: render_found, id: generated_id, type: :shadow,
-  #                    attach: parent_found,
-  #                    red: 0, green: 0, blue: 0, alpha: 1, blur: 3, left: 3, top: 3 }
-
-
-  default_params = {red: 0, green: 0, blue: 0, alpha: 1, blur: 3, left: 3, top: 3 }
-
+  default_params = { red: 0, green: 0, blue: 0, alpha: 1, blur: 3, left: 3, top: 3 }
   new_params = default_params.merge!(params)
-  # atome[:shadow] = [new_params[:id]]
   new_params
 end
 new({ atome: :shape })
@@ -138,20 +36,11 @@ new({ atome: :code })
 new({ atome: :audio })
 new({ atome: :element })
 new({ sanitizer: :element }) do |params|
-  # parent_found = found_parents_and_renderers[:parent]
-  # render_found = []
-  # generated_id = params[:id] || identity_generator(:element)
-
   default_params = { data: '' }
   default_params.merge!(params)
 end
 new({ atome: :web })
 new({ sanitizer: :web }) do |params|
-  # default_renderer = Essentials.default_params[:render_engines]
-  # generated_id = params[:id] || identity_generator(:web)
-  #
-  # generated_render = params[:renderers] || default_renderer
-  # generated_parents = params[:attach] || id.value
   # TODO : the line below should get the value from default params Essentials
   temp_default = { path: 'https://www.youtube.com/embed/usQDazZKWAk' }
   params = temp_default.merge(params)
@@ -159,23 +48,8 @@ new({ sanitizer: :web }) do |params|
 end
 new({ atome: :collector })
 new({ atome: :animation })
-# new({ sanitizer: :animation }) do |params|
-#   default_renderer = Essentials.default_params[:render_engines]
-#   atome_type = :animation
-#   generated_render = params[:renderers] || default_renderer
-#   generated_id = params[:id] || identity_generator(atome_type)
-#   generated_parents = params[:attach] || []
-#   params = atome_common(atome_type, generated_id, generated_render, generated_parents, params)
-#   params
-# end
 new({ atome: :text, type: :hash })
 new({ sanitizer: :text }) do |params|
   params = { data: params } unless params.instance_of? Hash
-  # default_renderer = Essentials.default_params[:render_engines]
-  # atome_type = :text
-  # generated_render = params[:renderers] || default_renderer
-  # generated_id = params[:id] || identity_generator(atome_type)
-  # generated_parents = params[:attach] || [id.value]
-  # params = atome_common(atome_type, generated_id, generated_render, generated_parents, params)
   params
 end

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

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

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

@@ -3,9 +3,3 @@
 
 new({ particle: :smooth })
 new({ particle: :blur })
-
-
-# generator = Genesis.generator
-#
-# generator.build_particle(:smooth)
-# generator.build_particle(:blur)