atome 0.5.3.8.1 → 0.5.4.0.9

data/lib/atome/extensions/matrix.rb

@@ -1,40 +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 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)
-    collector_object = collector({})
-    collected_atomes = []
-    cell_nb.each do |cell_found|
-      atome_found = grab("#{id}_#{cell_found}")
-      collected_atomes << atome_found
+  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)
@@ -65,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]
@@ -79,7 +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}")
+          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,9 +261,7 @@ 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.children.each do |child|
-          # puts "=>#{cell_width}"
+        current_cell.materials.each do |child|
           grab(child).width(cell_width) if grab(child)
           grab(child).height(cell_width) if grab(child)
         end
@@ -188,143 +274,15 @@ module Matrix
     end
 
     # exceptions management
-
-    number_of_cells = nb_of_rows * nb_of_cols
-    # columns exceptions
     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[: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 }
-      # @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
-    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
@@ -332,22 +290,12 @@ 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
     @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
 
@@ -357,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
@@ -405,3 +342,5 @@ end
 class Atome
   include Matrix
 end
+
+

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

@@ -1,138 +1,55 @@
 # frozen_string_literal: true
-
 new({ atome: :color, type: :hash })
 
 new({ sanitizer: :color }) do |params|
-  parent_found = found_parents_and_renderers[:parent]
-  if parent_found == [:black_matter]
-
-  elsif color.value
-    # 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 }
+  # TODO : when attaching color to a shadow it should colorized it , cf : c.shadow({color: :blue}) should work
   params = create_color_hash(params) unless params.instance_of? Hash
-  new_params = default_params.merge!(params)
-  atome[:color] = new_params[:id]
-  new_params
+  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[:parents] || id.value
   # TODO : the line below should get the value from default params Essentials
-  temp_default = { renderers: generated_render, id: generated_id, type: :image, parents: [generated_parents],
-                   children: [], width: 99, height: 99, path: './medias/images/atome.svg' }
-  params = temp_default.merge(params)
   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,
-                     parents: parent_found }
-  default_params.merge!(params)
-end
-new({ atome: :shadow })
+new({ atome: :shadow, type: :hash })
 new({ sanitizer: :shadow }) do |params|
-
-  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
-    # so it is not sanitized so it has no id
-  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.merge!(params)
-  params = create_shadow_hash(params) unless params.instance_of? Hash
+  # TODO : when attaching color to a shadow it should colorised it , cf : c.shadow({color: :blue}) should work
+  params = {} unless params.instance_of? Hash
+  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
   new_params
-
 end
 new({ atome: :shape })
 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 = { renderers: render_found, id: generated_id, type: :element,
-                     parents: parent_found, data: '' }
+  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[:parents] || id.value
   # TODO : the line below should get the value from default params Essentials
-  temp_default = { renderers: generated_render, id: generated_id, type: :web, parents: [generated_parents],
-                   children: [], width: 120, height: 120, path: 'https://www.youtube.com/embed/usQDazZKWAk' }
+  temp_default = { path: 'https://www.youtube.com/embed/usQDazZKWAk' }
   params = temp_default.merge(params)
   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[:parents] || []
-  generated_children = params[:children] || []
-  params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, 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[:parents] || [id.value]
-  generated_children = params[:children] || []
-  params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, 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)