atome 0.5.3.2 → 0.5.3.7.2

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

@@ -1,39 +1,36 @@
 # frozen_string_literal: true
 
-generator = Genesis.generator
-
-generator.build_particle(:red) do
+new({ 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
+new({ 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
+new({ 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
+new({ 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
+new({ 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)
-generator.build_particle(:style)
-generator.build_option(:pre_render_style) do |styles_send, _user_proc|
+new({ particle: :visual })
+new({ particle: :overflow })
+new({ particle: :edit })
+new({ particle: :style })
+new({ pre: :style }) do |styles_send, _user_proc|
   styles_send.each do |particle_send, value|
     send(particle_send, value)
   end
 end
-generator.build_particle(:hide)
-
-generator.build_particle(:remove) do |particle_to_remove|
+new({ particle: :hide })
+new({ particle: :remove }) do |particle_to_remove|
   case particle_to_remove
   when :color
     send(particle_to_remove, :black)
@@ -41,6 +38,67 @@ generator.build_particle(:remove) do |particle_to_remove|
     # TODO : code to write
     puts 'code to write'
   else
-    send(particle_to_remove, 0)
+    particle_to_remove_decision(particle_to_remove)
   end
 end
+new({ particle: :classes }) do |value|
+  Universe.classes[value] ||= []
+  Universe.classes[value] |= [id.value]
+end
+new({ particle: :remove_classes }) do |value|
+  # Universe.classes.delete(value)
+  Universe.classes[value].delete(id.value)
+end
+new ({particle: :opacity})
+
+# generator = Genesis.generator
+#
+# 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)
+# generator.build_particle(:style)
+# generator.build_option(:pre_render_style) do |styles_send, _user_proc|
+#   styles_send.each do |particle_send, value|
+#     send(particle_send, value)
+#   end
+# end
+# generator.build_particle(:hide)
+# generator.build_particle(:remove) do |particle_to_remove|
+#   case particle_to_remove
+#   when :color
+#     send(particle_to_remove, :black)
+#   when :shadow
+#     # TODO : code to write
+#     puts 'code to write'
+#   else
+#     particle_to_remove_decision(particle_to_remove)
+#   end
+# end
+# generator.build_particle(:classes) do |value|
+#   Universe.classes[value] ||= []
+#   Universe.classes[value] |= [id.value]
+# end
+# generator.build_particle(:remove_classes) do |value|
+#   # Universe.classes.delete(value)
+#   Universe.classes[value].delete(id.value)
+# end

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

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
-generator = Genesis.generator
-# create particles
-generator.build_particle(:left) do |_params, user_proc|
+new({ particle: :left }) do |_params, user_proc|
   instance_exec(&user_proc) if user_proc.is_a?(Proc)
 end
+new({ particle: :right })
+new({ particle: :top })
+new({ particle: :bottom })
+new({ particle: :rotate })
+new({ particle: :direction })
+new({ particle: :center })
+new ({particle: :depth})
 
-generator.build_particle(:right)
-generator.build_particle(:top)
-generator.build_particle(:bottom)
-generator.build_particle(:rotate)
-generator.build_particle(:direction)
-generator.build_particle(:center)

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

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

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

@@ -1,36 +1,16 @@
 # frozen_string_literal: true
 
-generator = Genesis.generator
 
-generator.build_particle(:renderers)
-generator.build_particle(:code)
-generator.build_particle(:run) do |params|
+new({particle: :renderers })
+new({particle: :code })
+new({particle: :run }) do |params|
   code_found = @atome[:code]
   instance_exec(params, &code_found) if code_found.is_a?(Proc)
 end
-generator.build_particle(:broadcast)
-generator.build_particle(:additional)
-generator.build_particle(:data)
-# generator.build_particle(:delete) do |params|
-#   if params == true
-#     # the machine delete the current atome
-#     Universe.delete(@atome[:id])
-#   elsif params[:id]
-#     # the machine try to an atome by it's ID and delete it
-#     grab(params[:id]).delete(true)
-#   elsif instance_of? Hash
-#     # the machine try to find the sub particle id and remove it eg a.delete(monitor: :my_monitor) remove the monitor
-#     # with id my_monitor
-#     params.each do |param, value|
-#       atome[param][value] = nil
-#     end
-#   else
-#     # the machine try to reset the current particle(params), eg a.delete(:left) => left: 0
-#     send(params,0)
-#   end
-# end
-
-generator.build_particle(:delete) do |params|
+new({particle: :broadcast })
+new({particle: :data })
+new({particle: :additional })
+new({particle: :delete }) do |params|
   if params == true
     # the machine delete the current atome
     Universe.delete(@atome[:id])
@@ -44,14 +24,13 @@ generator.build_particle(:delete) do |params|
       atome[param][value] = nil
     end
   else
-    #   # the machine try to reset the current particle(params), eg a.delete(:left) => left: 0
-    send(params,0)
+    # the machine try to reset the current particle(params), eg a.delete(:left) => left: 0
+    send(params, 0)
   end
 end
-
-generator.build_particle(:clear)
-generator.build_particle(:path)
-generator.build_particle(:schedule) do |date, proc|
+new({particle: :clear })
+new({particle: :path })
+new({particle: :schedule }) do |date, proc|
   date = date.to_s
   delimiters = [',', ' ', ':', '-']
   format_date = date.split(Regexp.union(delimiters))
@@ -59,15 +38,63 @@ generator.build_particle(:schedule) do |date, proc|
     send("#{renderer}_schedule", format_date, &proc)
   end
 end
-generator.build_particle(:read) do |file, proc|
+new({particle: :read }) do |file, proc|
   Universe.renderer_list.each do |renderer|
     send("#{renderer}_reader", file, &proc)
   end
 end
+new({particle: :cursor })
+new({particle: :preset })
+new({particle: :relations,type: :hash  })
 
-generator.build_particle(:cursor)
-
-generator.build_particle(:preset)
-
-generator.build_particle(:relations, { type: :hash })
 
+# generator = Genesis.generator
+#
+#
+#
+#
+# generator.build_particle(:renderers)
+# generator.build_particle(:code)
+# generator.build_particle(:run) do |params|
+#   code_found = @atome[:code]
+#   instance_exec(params, &code_found) if code_found.is_a?(Proc)
+# end
+# generator.build_particle(:broadcast)
+# generator.build_particle(:additional)
+# generator.build_particle(:data)
+# generator.build_particle(:delete) do |params|
+#   if params == true
+#     # the machine delete the current atome
+#     Universe.delete(@atome[:id])
+#   elsif params[:id]
+#     # the machine try to an atome by it's ID and delete it
+#     grab(params[:id]).delete(true)
+#   elsif params.instance_of? Hash
+#     # the machine try to find the sub particle id and remove it eg a.delete(monitor: :my_monitor) remove the monitor
+#     # with id my_monitor
+#     params.each do |param, value|
+#       atome[param][value] = nil
+#     end
+#   else
+#     # the machine try to reset the current particle(params), eg a.delete(:left) => left: 0
+#     send(params, 0)
+#   end
+# end
+# generator.build_particle(:clear)
+# generator.build_particle(:path)
+# generator.build_particle(:schedule) do |date, proc|
+#   date = date.to_s
+#   delimiters = [',', ' ', ':', '-']
+#   format_date = date.split(Regexp.union(delimiters))
+#   Universe.renderer_list.each do |renderer|
+#     send("#{renderer}_schedule", format_date, &proc)
+#   end
+# end
+# generator.build_particle(:read) do |file, proc|
+#   Universe.renderer_list.each do |renderer|
+#     send("#{renderer}_reader", file, &proc)
+#   end
+# end
+# generator.build_particle(:cursor)
+# generator.build_particle(:preset)
+# generator.build_particle(:relations, { type: :hash })

data/lib/atome/genesis/genesis.rb

@@ -11,7 +11,7 @@ end
 
 # Genesis method here
 class Atome
-  def build_particle(particle_name,options={},&particle_proc)
+  def build_particle(particle_name, options = {}, &particle_proc)
     type = options[:type]
     type = :string if options[:type].nil?
     store = options[:store]
@@ -21,15 +21,17 @@ class Atome
 
     # we add the new method to the particle's collection of methods
     Universe.add_to_particle_list(particle_name, type)
-    auto_render_generator(particle_name) if render #  automatise the creation of an empty render method for current particle
-    new_particle(particle_name,store,render , &particle_proc)
-    additional_particle_methods(particle_name, store,render ,&particle_proc) # create alternative methods such as create 'method='
+    # the line below create an empty particle method for each renderer, eg: browser_left, headless_left, ...
+    auto_render_generator(particle_name) if render
+    new_particle(particle_name, store, render, &particle_proc)
+    # the line below create all alternatives methods such as create 'method='
+    additional_particle_methods(particle_name, store, render, &particle_proc)
   end
 
-
   def build_atome(atome_name, &atome_proc)
     # we add the new method to the atome's collection of methods
     Universe.add_to_atome_list(atome_name)
+    # the line below create an empty atome method for each renderer, eg: browser_left, headless_left, ...
     auto_render_generator(atome_name)
     new_atome(atome_name, &atome_proc)
   end

data/lib/atome/genesis/sparkle.rb

@@ -38,7 +38,7 @@ Atome.new(
 # color creation
 Atome.new(
   { color: { renderers: default_render, id: :view_color, type: :color,
-             red:  0.15, green: 0.15, blue: 0.15, alpha: 1 } }
+             red: 0.15, green: 0.15, blue: 0.15, alpha: 1 } }
 )
 
 Atome.new(
@@ -66,7 +66,13 @@ Atome.new(
              left: 0, top: 0, red: 0.7, green: 0.7, blue: 0.7, alpha: 1, diffusion: :linear } }
 )
 
-# view creation
+# system object creation
+# the black_matter is used to store un materialized atomes
+Atome.new(
+  { shape: { renderers: default_render, id: :black_matter, type: :shape, parents: [:user_view], children: [],
+             left: 0, right: 0, top: 0, bottom: 0, width: 0, height: 0, overflow: :hidden
+  } })
+# view port
 Atome.new(
   { shape: { renderers: default_render, id: :view, type: :shape, parents: [:user_view], children: [],
              attached: [:view_color], left: 0, right: 0, top: 0, bottom: 0, width: :auto, height: :auto, overflow: :auto

data/lib/atome/helpers/essentials.rb

@@ -4,27 +4,23 @@
 module Essentials
   @default_params = {
     render_engines: [:browser],
+    collector: { type: :element, renderers: [], children: [] },
     animation: { type: :animation, children: [] },
     element: { type: :element, renderers: [], children: [] },
     matrix: { renderers: [], id: '', type: :shape, parents: [], width: 99, height: 99,
               attached: [:matrix_color], children: [],
-              # color: { left: 0, top: 0,  red: 0.1, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
               left: 100, top: 100, clones: [], preset: :matrix },
     box: { renderers: [], id: '', type: :shape, parents: [], width: 99, height: 99,
            attached: [:box_color], children: [],
-           # color: { left: 0, top: 0,  red: 1, green: 0.3, blue: 0.3, alpha: 1, diffusion: :linear },
            left: 100, top: 100, clones: [], preset: :box },
     circle: { renderers: [], id: '', type: :shape, parents: [], width: 99, height: 99, smooth: '100%',
-              # color: { left: 0, top: 0,  red: 0.3, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
               attached: [:circle_color], children: [],
               left: 100, top: 100, clones: [], preset: :circle },
     shape: { renderers: [], id: '', type: :shape, parents: [], width: 99, height: 99,
-             attached: [:view_color], children: [],
-             # color: { left: 0, top: 0,  red: 0.6, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
+             attached: [:shape_color], children: [],
              left: 100, top: 100, clones: [] },
     text: { renderers: [], id: '', type: :text, parents: [:view], visual: { size: 25 },
             attached: [:text_color], children: [],
-            # color: { left: 0, top: 0, red: 0.3, green: 0.3, blue: 0.3, alpha: 1, diffusion: :linear },
             data: 'this is a text sample', width: 199, height: 33, clones: [] },
     drm: { type: :drm },
     shadow: {},

data/lib/atome/helpers/utilities.rb

@@ -133,10 +133,25 @@ class Atome
     end
 
   end
+  def []=(params, value)
+    # TODO : it may miss some code, see above
+    self.value[params] = value
+  end
 
   def set(params)
     params.each do |particle, value|
       send(particle, value)
     end
   end
+
+  def particle_to_remove_decision(particle_to_remove)
+    if particle_to_remove.instance_of? Hash
+      particle_to_remove.each do |particle_found, value|
+        send("remove_#{particle_found}", value)
+      end
+    else
+      send(particle_to_remove, 0)
+    end
+  end
+
 end

data/lib/atome/kernel/universe.rb

@@ -3,14 +3,14 @@
 # universe method here
 class Universe
   @atomes = {}
+  @classes = {}
   @atome_list = []
   @particle_list = {}
   @renderer_list = %i[html browser headless server]
   @options = {}
   @sanitizers = {}
-
   class << self
-    attr_reader :atomes, :renderer_list, :atome_list, :particle_list
+    attr_reader :atomes, :renderer_list, :atome_list, :particle_list, :classes
 
     def add_to_particle_list(particle = nil, type)
       instance_variable_get('@particle_list')[particle]=type

data/lib/atome/presets/atome.rb

@@ -17,7 +17,6 @@ class Atome
     temp_default.merge(params)
   end
 
-
   def box(params = {}, &bloc)
     default_renderer = Essentials.default_params[:render_engines]
     atome_type = :box
@@ -28,13 +27,6 @@ class Atome
 
     params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
 
-    # params2 =  { renderers: [:browser], id: generated_id, type: :shape, parents: [generated_parents], children: [],
-    #              width: 99, height: 99,
-    #              color: { renderers: [:browser], id: "#{params[:id]}_color", type: :color, attach: [params[:id]],
-    #                       red: 0.15, green: 0.30, blue: 0.6, alpha: 1 },
-    #              left: 100, top: 100, clones: [], preset: :box
-    # }
-    # params[:children]=[]
     Atome.new({ atome_type => params }, &bloc)
   end
 
@@ -49,60 +41,67 @@ class Atome
     Atome.new({ atome_type => params }, &bloc)
   end
 
-  def image(params = {}, &bloc)
-    default_renderer = Essentials.default_params[:render_engines]
-    generated_id = params[:id] || "image_#{Universe.atomes.length}"
-    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)
-    Atome.new({ image: params }, &bloc)
-  end
-
-  def text(params = {}, &bloc)
-    default_renderer = Essentials.default_params[:render_engines]
-    atome_type = :text
-    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)
-    Atome.new({ atome_type => params }, &bloc)
-  end
-
-  def element(params = {}, &bloc)
-    atome_type = :element
-    generated_render = params[:renderers] || []
-    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)
-    Atome.new({ atome_type => params }, &bloc)
-  end
+  # def image(params = {}, &bloc)
+  #   default_renderer = Essentials.default_params[:render_engines]
+  #   generated_id = params[:id] || "image_#{Universe.atomes.length}"
+  #   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)
+  #   Atome.new({ image: params }, &bloc)
+  # end
+  #
+  # def text(params = {}, &bloc)
+  #   default_renderer = Essentials.default_params[:render_engines]
+  #   atome_type = :text
+  #   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)
+  #   Atome.new({ atome_type => params }, &bloc)
+  # end
 
-  def web(params = {}, &bloc)
-    default_renderer = Essentials.default_params[:render_engines]
+  # def element(params = 'kjh', &bloc)
+  #   atome_type = :element
+  #
+  #   generated_render = params[:renderers] || []
+  #
+  #   generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
+  #   generated_parents = params[:parents] || [id.value]
+  #   generated_children = params[:children] || []
+  #
+  #   generated_data = ""
+  #   params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
+  #   # FIXME: do not merge generated_data like this but change the atomecommon
+  #   params.merge(generated_data)
+  #
+  #   Atome.new({ atome_type => params }, &bloc)
+  # end
 
-    generated_id = params[:id] || "web_#{Universe.atomes.length}"
-    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' }
-    params = temp_default.merge(params)
-    Atome.new({ image: params }, &bloc)
-  end
+  # def web(params = {}, &bloc)
+  #   default_renderer = Essentials.default_params[:render_engines]
+  #
+  #   generated_id = params[:id] || "web_#{Universe.atomes.length}"
+  #   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' }
+  #   params = temp_default.merge(params)
+  #   Atome.new({ image: params }, &bloc)
+  # end
 
-  def animation(params = {}, &bloc)
-    default_renderer = Essentials.default_params[:render_engines]
-    atome_type = :animation
-    generated_render = params[:renderers] || default_renderer
-    generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
-    generated_parents = params[:parents] || []
-    generated_children = params[:children] || []
-    params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
-    Atome.new({ atome_type => params }, &bloc)
-  end
+  # def animation(params = {}, &bloc)
+  #   default_renderer = Essentials.default_params[:render_engines]
+  #   atome_type = :animation
+  #   generated_render = params[:renderers] || default_renderer
+  #   generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
+  #   generated_parents = params[:parents] || []
+  #   generated_children = params[:children] || []
+  #   params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
+  #   Atome.new({ atome_type => params }, &bloc)
+  # end
 end

data/lib/atome/renderers/browser/event.rb

@@ -4,8 +4,11 @@ generator = Genesis.generator
 
 generator.build_render(:browser_touch) do |value, proc|
   atome_id = @browser_object.attribute(:id)
-  BrowserHelper.send("browser_touch_#{value}", atome_id, proc)
-  # end
+  BrowserHelper.send("browser_touch_#{value}", atome_id,self, proc)
+end
+
+generator.build_render(:browser_over) do |value, proc|
+  BrowserHelper.send("browser_over_#{value}", @browser_object,self, proc)
 end
 
 generator.build_render(:browser_play) do |value, proc|
@@ -62,7 +65,7 @@ end
 generator.build_render(:browser_unbind) do |options, _proc|
   id_found = self.atome[:id]
   `
-const el = document.getElementById(#{id_found});
+//const el = document.getElementById(#{id_found});
 interact('#'+#{id_found}).unset(#{options});
 `
 end

data/lib/atome/renderers/browser/geometry.rb

@@ -3,17 +3,25 @@
 generator = Genesis.generator
 
 generator.build_render(:browser_width) do |value|
-  @browser_object.style[:width] = if value.instance_of? String
-                                    value
-                                  else
-                                    "#{value}px"
-                                  end
+
+  # aa=BrowserHelper.value_parse(value)
+  # # alert "value_parse : #{aa}"≈
+  # alert "#{value} :  #{value.class} : value_parse : #{aa}"
+  # @browser_object.style[:width] = if value.instance_of? String
+  #                                   value
+  #                                 else
+  #                                   "#{value}px"
+  #                                 end
+
+
+  @browser_object.style[:width] = BrowserHelper.value_parse(value)
 end
 
 generator.build_render(:browser_height) do |value|
-  @browser_object.style[:height] = if value.instance_of? String
-                                     value
-                                   else
-                                     "#{value}px"
-                                   end
+  # @browser_object.style[:height] = if value.instance_of? String
+  #                                    value
+  #                                  else
+  #                                    "#{value}px"
+  #                                  end
+  @browser_object.style[:height] = BrowserHelper.value_parse(value)
 end

data/lib/atome/renderers/browser/helpers/browser_helper.rb

@@ -14,4 +14,13 @@ module BrowserHelper
   def self.browser_attach_style(parents, _html_object, atome)
     browser_document[parents].add_class(atome[:id])
   end
+
+  def self.value_parse(value)
+    if value.instance_of?(String)
+      value
+    else
+      "#{value}px"
+    end
+
+  end
 end

data/lib/atome/renderers/browser/helpers/color_helper.rb

@@ -16,18 +16,18 @@ module BrowserHelper
   end
 
   def self.browser_left_color(_value, _browser_object, _atome)
-    puts 'code to write when implementing gradient'
+    # puts 'code to write when implementing gradient'
   end
 
   def self.browser_right_color(_value, _browser_object, _atome)
-    puts 'code to write when implementing gradient'
+    # puts 'code to write when implementing gradient'
   end
 
   def self.browser_top_color(_value, _browser_object, _atome)
-    puts 'code to write when implementing gradient'
+    # puts 'code to write when implementing gradient'
   end
 
   def self.browser_bottom_color(_value, _browser_object, _atome)
-    puts 'code to write when implementing gradient'
+    # puts 'code to write when implementing gradient'
   end
 end