atome 0.5.2.8 → 0.5.3.2

data/lib/atome/extensions/matrix.rb

@@ -1,171 +1,398 @@
 # frozen_string_literal: true
 
-# powerful and simple to use table and list generator
-class Matrix
-  attr_accessor :matrix
+class Atome
+  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([self.id])
+    else
+      @cell_content
+    end
 
-  def create_matrix_back( id, style)
-    @matrix = Atome.new(
-      shape: { type: :shape, renderers: [:browser], id: id, parents: [:view], children: [:matrix_color],
-               overflow: :auto }
-    )
-    @matrix.style(style)
   end
 
-  def create_matrix_colors
-    Atome.new({ color: { renderers: [:browser], id: :matrix_color, type: :color, parents: [], children: [],
-                         red: 0, green: 1, blue: 1, alpha: 1 } })
+  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
+    end
+    collector_object.data(collected_atomes)
+    collector_object
+  end
 
-    Atome.new({ color: { renderers: [:browser], id: :cell_color, type: :color, parents: [], children: [],
-                         red: 1, green: 0.15, blue: 0.7, alpha: 1 } })
+  def cell(cell_nb)
+    cell_found = grab ("#{id}_#{cell_nb}")
+    cell_found
   end
 
-  def create_cells(id, cell_number, number_of_cells, style)
-    while cell_number < number_of_cells
-      @matrix_dataset[cell_number] = []
-      @cells << a = Atome.new(
-        shape: { type: :shape, renderers: [:browser], id: id + "_#{cell_number}", parents: [id],
-                 children: [:cell_color] }
-      )
-      a.style(style)
-      cell_number += 1
+  def columns(column_requested, &proc)
+    number_of_cells = @columns * @rows
+    column_content = get_column_or_row(number_of_cells, @columns, column_requested, true)
+    cells_found = []
+    column_content.each do |cell_nb|
+      atome_found = grab("#{id}_#{cell_nb}")
+      instance_exec(atome_found, &proc) if proc.is_a?(Proc)
+      cells_found << grab("#{id}_#{cell_nb}")
     end
+    element({ data: cells_found })
   end
 
-  def initialize(params)
-    default = { col: 4, row: 4, size: 333, margin: 12, name: :matrix, parent: :view }
-    params = default.merge(params)
-    nb_of_rows = params[:row]
-    nb_of_cols = params[:col]
-    matrix_width = params[:width]
-    matrix_height = params[:height]
+  def rows(row_requested, &proc)
+    number_of_cells = @columns * @rows
+    column_content = get_column_or_row(number_of_cells, @columns, row_requested, false)
+    cells_found = []
+    column_content.each do |cell_nb|
+      atome_found = grab("#{id}_#{cell_nb}")
+      instance_exec(atome_found, &proc) if proc.is_a?(Proc)
+      cells_found << grab("#{id}_#{cell_nb}")
+    end
+    element({ data: cells_found })
+  end
 
-    @matrix_dataset = []
-    @matrix_margin = params[:margin]
-    params[:id] = :matrix unless params[:id]
-    @matrix_id = params[:id]
-    # styles
-    @matrix_style = params[:matrix_style]
-    @cell_style = params[:cell_style]
-    # Colors
-    create_matrix_colors
-    # now we create the background
-    create_matrix_back( @matrix_id, @matrix_style)
-
-    @nb_of_rows = nb_of_rows.to_i
-    @nb_of_cols = nb_of_cols.to_i
-    number_of_cells = @nb_of_rows * @nb_of_cols
-    @cells = []
-    cell_number = 0
-    create_cells(@matrix_id, cell_number, number_of_cells, @cell_style)
-
-    resize_matrix({ width: matrix_width, height: matrix_height })
-  end
-
-  def width(val = nil)
-    if val
-      resize_matrix({ height: height, width: val })
+  # def ratio(val)
+  #   puts "ratio must be : #{val}"
+  #
+  # end
+
+  def fusion(params)
+    number_of_cells = @columns * @rows
+    if params[:columns]
+      @exceptions[:columns_fusion] = params[:columns].merge(@exceptions[:columns_fusion])
+      params[:columns].each do |column_to_alter, value|
+        cell_height = (@matrix_height - @margin * (@rows + 1)) / @rows
+        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}")
+          if index == 0
+            current_cell.height(cell_height * cells_to_alter.length + @margin * (cells_to_alter.length - 1))
+          else
+            current_cell.hide(true)
+          end
+        end
+      end
     else
-      @matrix.width.value
+      @exceptions[:rows_fusion] = params[:rows].merge(@exceptions[:rows_fusion])
+      params[:rows].each do |row_to_alter, value|
+        cell_width = (@matrix_width - @margin * (@columns + 1)) / @columns
+        cells_in_column = get_column_or_row(number_of_cells, @columns, row_to_alter, false)
+        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}")
+          if index == 0
+            current_cell.width(cell_width * cells_to_alter.length + @margin * (cells_to_alter.length - 1))
+          else
+            current_cell.hide(true)
+          end
+        end
+      end
     end
 
   end
 
-  def height(val = nil)
-    if val
-      resize_matrix({ width: width, height: val })
+  def divide(params)
+    number_of_cells = @columns * @rows
+    if params[:columns]
+      params[:columns].each do |column_to_alter, value|
+        cells_in_column = get_column_or_row(number_of_cells, @columns, column_to_alter, true)
+        #  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}")
+          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))
+          else
+            current_cell.hide(true)
+          end
+        end
+      end
     else
-      @matrix.height.value
+      params[:rows].each do |row_to_alter, value|
+        cells_in_row = get_column_or_row(number_of_cells, @columns, row_to_alter, false)
+        #  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}")
+          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))
+          else
+            current_cell.hide(true)
+          end
+        end
+      end
     end
+
   end
 
-  def left(val)
-    @matrix.left(val)
+  # 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)
+    else
+      rows(0, &proc)
+    end
   end
 
-  def right(val)
-    @matrix.right(val)
+  def last(item, &proc)
+    if item[:columns]
+      columns(@columns - 1, &proc)
+    else
+      rows(@rows - 1, &proc)
+    end
   end
 
-  def resize_matrix(params)
-    matrix_width = params[:width]
-    matrix_height = params[:height]
-    cell_width = (matrix_width / @nb_of_cols) - @matrix_margin
-    cell_height = (matrix_height / @nb_of_rows) - @matrix_margin
-    row = -1
-    @cells.each_with_index do |cell, index|
-      cell.height = cell_height
-      cell.width = cell_width
-      row += 1 if index.modulo(@nb_of_cols).zero?
-      cell.left(index % @nb_of_cols * (cell_width + @matrix_margin) + @matrix_margin)
-      cell.top(row * (cell_height + @matrix_margin) + @matrix_margin)
+  def format_matrix(matrix_id, matrix_width, matrix_height, nb_of_rows, nb_of_cols, margin, exceptions = {})
+    cell_width = (matrix_width - margin * (nb_of_cols + 1)) / nb_of_cols
+    cell_height = (matrix_height - margin * (nb_of_rows + 1)) / nb_of_rows
+    ratio=cell_height/cell_width
+    i = 0
+    nb_of_rows.times do |row_index|
+      nb_of_cols.times do |col_index|
+        # Calculate the x and y position of the cell
+        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.children.each do |child|
+          puts "=>#{cell_width}"
+          grab(child).width(cell_width)
+          grab(child).height(cell_width)
+        end
+        current_cell.width= cell_width
+        current_cell.height= cell_height
+        current_cell.left(x)
+        current_cell.top(y)
+        i += 1
+      end
     end
 
-    @matrix.width = matrix_width + @matrix_margin
-    @matrix.height = matrix_height + @matrix_margin
-  end
+    # exceptions management
+
+    number_of_cells = nb_of_rows * nb_of_cols
+    # columns exceptions
+    if 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 get_cell(id)
-    grab("#{@matrix_id}_#{id}")
   end
 
-  def delete(val = true)
-    @matrix.delete(true) if val
+  def apply_style(current_cell, style)
+    current_cell.set(style)
   end
 
-  attr_reader :cells
+  def matrix(params = {}, &bloc)
 
-  def name
-    @matrix.name
-  end
+    if  params[:columns]
+      columns_data = params.delete(:columns)
+    else
+      columns_data= {  count: 4 }
+    end
 
-  def get_cell_data(codes, cell_nb)
-    codes.each do |proc|
-      if proc.is_a? Proc
-        assign(cell_nb, &proc)
-      end
+    if  params[:rows]
+      rows_data = params.delete(:rows)
+    else
+      rows_data= {  count: 4 }
     end
-  end
 
-  def add(params)
-    nb_of_cols = @nb_of_cols + params[:columns].to_i
-    nb_of_rows = @nb_of_rows + params[:rows].to_i
-    current_id = @matrix.atome[:id]
-    # we delete all children to unbind any event
-    @cells.each do |cell|
-      cell.delete(true)
-      cell.unbind(:all)
+    if  params[:cells]
+      cells_data = params.delete(:cells)
+    else
+      cells_data= { 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] || "#{atome_type}_#{Universe.atomes.length}"
+    generated_parents = params[:parents] || [id.value]
+    generated_children = params[:children] || []
+    params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
+    the_matrix = Atome.new({ atome_type => params }, &bloc)
+
+    # 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 }
+      the_matrix.instance_variable_set("@exceptions", 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: {},
+      }
+      the_matrix.instance_variable_set("@exceptions", exceptions)
+      # @exceptions = {
+      #   columns_fusion: {},
+      #   columns_divided: {},
+      #   rows_fusion: {},
+      #   rows_divided: {},
+      # }
     end
-    temp_id = "#{current_id}_temporary"
-    @matrix.id = temp_id
-    old_matrix=grab(temp_id)
 
-    old_matrix.delete(true)
+    # 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
+    the_matrix.format_matrix(matrix_id, matrix_width, matrix_height, rows, columns, margin, exceptions)
+    the_matrix
+  end
 
-    Matrix.new({ col: nb_of_cols, row: nb_of_rows, width: 300, height: 300, id: current_id,  margin: @matrix_margin,
-                 matrix_style: @matrix_style,
-                 cell_style: @cell_style
-               })
+  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
+        #
+      end
+      current_cell = self.box({ id: "#{id}_#{index}" })
+      apply_style(current_cell, @cell_style)
+    end
+    @columns = @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
 
-    @matrix_dataset.each_with_index do |cell_data, index|
-      get_cell_data(cell_data, index)
+  def add_rows(nb)
+    prev_nb_of_cells = @columns * @rows
+    nb_of_cells_to_adds = nb * @columns
+    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
+        #
+      end
+      current_cell = self.box({ id: "#{id}_#{index}" })
+      apply_style(current_cell, @cell_style)
     end
+    @rows = @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)
+    format_matrix(id, @matrix_width, @matrix_height, @rows, @columns, @margin, @exceptions)
   end
 
-  def assign(cell_nb = nil, &proc)
-    current_cell = grab("#{@matrix_id}_#{cell_nb}")
-    if proc
-      @matrix_dataset[cell_nb] << proc
-      current_cell.instance_exec(&proc) if proc.is_a? Proc
+  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
+      result = []
+      (0...num_rows).each do |row|
+        result << (index + row * num_columns)
+      end
+      return result
     else
-      @matrix_dataset[cell_nb]
+      start_index = index * num_columns
+      end_index = start_index + num_columns - 1
+      return (start_index..end_index).to_a
     end
   end
 
-  def reformat(params)
-    @nb_of_rows = params[:rows]
-    @nb_of_cols = params[:cols]
-    resize_matrix({ height: height, width: width })
-  end
 end

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

@@ -6,6 +6,7 @@ generator.build_atome(:animation)
 generator.build_atome(:color)
 generator.build_sanitizer(:color) do |params|
   parent_found = found_parents_and_renderers[:parent]
+  parent_found = [:user_view] if parent_found == [:view]
   render_found = found_parents_and_renderers[:renderers]
   default_params = { renderers: render_found, id: "color_#{Universe.atomes.length}", type: :color,
                      attach: parent_found,
@@ -27,10 +28,11 @@ generator.build_atome(:shadow)
 
 generator.build_sanitizer(:shadow) do |params|
   parent_found = found_parents_and_renderers[:parent]
+  parent_found = [:user_view] if parent_found == [:view]
   render_found = found_parents_and_renderers[:renderers]
   default_params = { renderers: render_found, id: "shadow_#{Universe.atomes.length}", type: :shadow,
                      attach: parent_found,
-                     red: 0, green: 0, blue: 0, alpha: 1 , blur: 3, left: 3, top: 3}
+                     red: 0, green: 0, blue: 0, alpha: 1, blur: 3, left: 3, top: 3 }
   default_params.merge!(params)
 end
 generator.build_atome(:shape)
@@ -48,3 +50,5 @@ generator.build_sanitizer(:element) do |params|
                      parents: parent_found }
   default_params.merge!(params)
 end
+
+generator.build_atome(:collector)

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

@@ -5,11 +5,34 @@ generator = Genesis.generator
 generator.build_particle(:type)
 generator.build_particle(:parents)
 generator.build_particle(:children)
+generator.build_option(:pre_render_parents) do |parents_ids|
+  parents_ids.each do |parents_id|
+    parents_id = parents_id.value if parents_id.instance_of? Atome
+    parents_found = grab(parents_id)
+    family(parents_id)
+    parents_found.atome[:children] << atome[:id]
+  end
+end
+
+generator.build_option(:pre_render_children) do |children_ids|
+  children_ids.each do |child_id|
+    child_id = child_id.value if child_id.instance_of? Atome
+    child_found = grab(child_id)
+    parents_found=@atome[:id]
+    child_found.family(parents_found)
+    child_found.atome[:parents] = [parents_found]
+  end
+end
+
+generator.build_particle(:family,{render: true,store: false})
+
+
 generator.build_particle(:link) do |child_id|
   child_found = grab(child_id)
   child_found.atome[:parents] << @atome[:id]
   child_found.refresh
 end
+
 generator.build_particle(:id)
 generator.build_sanitizer(:id) do |params|
   if @atome[:id] != params
@@ -19,29 +42,36 @@ generator.build_sanitizer(:id) do |params|
   end
   params
 end
-generator.build_option(:pre_render_parents) do |parents_id_found|
-  parents_id_found.each do |parents_id|
-    parents_found = grab(parents_id)
-    parents_found.children << id if parents_found
-  end
-end
+
 generator.build_particle(:name)
 
 generator.build_particle(:active)
 
-generator.build_particle(:attach) do |parents|
-  parents.each do |parent|
-    grab(parent).atome[:attached] = [atome[:id]]
+generator.build_particle(:attach)
+generator.build_particle(:attached)
+
+generator.build_option(:pre_render_attach) do |parents_ids|
+  parents_ids.each do |parents_id|
+    parents_id = parents_id.value if parents_id.instance_of? Atome
+    parents_found = grab(parents_id)
+    family(parents_id)
+    parents_found.atome[:attached] = [] unless parents_found.atome[:attached]
+    parents_found.atome[:attached] << atome[:id]
   end
 end
 
-generator.build_particle(:attached) do |targets|
-  targets.each do |target|
-    grab(target).attach([atome[:id]])
+generator.build_option(:pre_render_attached) do |children_ids|
+  children_ids.each do |child_id|
+    child_id = child_id.value if child_id.instance_of? Atome
+    child_found = grab(child_id)
+    parents_found=@atome[:id]
+    child_found.family(parents_found)
+    # parents_found.atome[:attach] = [] unless parents_found.atome[:attach]
+    child_found.atome[:attach] = [parents_found]
   end
 end
 
-generator.build_particle(:intricate, :array)
+generator.build_particle(:intricate, {type: :array })
 
 
 generator.build_particle(:clones) do |clones_found|

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

@@ -2,11 +2,26 @@
 
 generator = Genesis.generator
 
-generator.build_particle(:red)
-generator.build_particle(:green)
-generator.build_particle(:blue)
-generator.build_particle(:alpha)
-generator.build_particle(:diffusion)
+generator.build_particle(:red) do
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
+end
+generator.build_particle(:green) do
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
+end
+generator.build_particle(:blue) do
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
+end
+generator.build_particle(:alpha) do
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
+end
+generator.build_particle(:diffusion) do
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
+end
 generator.build_particle(:visual)
 generator.build_particle(:overflow)
 generator.build_particle(:edit)

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

@@ -2,4 +2,4 @@
 
 generator = Genesis.generator
 # create particles
-generator.build_particle(:markers, :hash)
+generator.build_particle(:markers, { type: :hash })