atome 0.5.3.4 → 0.5.3.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ca60550f747734b730b5f7bcc9e71f25bb116c0d084f2e8cb5f0bf601d33940
-  data.tar.gz: 175f194889b09b9969e7720bc10b9b100804685bad61fe7739bcd0ecba5e556f
+  metadata.gz: 5c9363d9399a6e64a2ba1fe03cf0be0f8a5ed36fa1d6ab58b59fc7cf7a2d4add
+  data.tar.gz: 43e83f421a13dba82a3c635f3cc593954fecfa265937f9e87db0fee73cb1897f
 SHA512:
-  metadata.gz: 2e7f1a2204f2551e05bdced2ffcc52d060af88156d7c43d824537abdfe00f75a7d574e52d18002835cf047d54176fdbe3dd80b0eecb9abf1c3ffe7c3dcbc3fce
-  data.tar.gz: 5ce1039aae51524cfbf2a91ca03d19f41e745640932eddd1362ae4fded9f1a5ee601ab8170c569d1d8f94a2927689be88716e8e4fcd8600f5630e213460815f5
+  metadata.gz: f6120ad4f0a7ac8288c612dd31dbb7a4314d778e55e4ab65939c831b9b9c8e2fcbb077a916fd7a7b82757e536ec056bd987a65ef6ebcf7686297087edc5ae35b
+  data.tar.gz: 4e27af6dd5d4f5b6de378f8e196c93a3788c8e0103eeb5848e58ab616370bdddd9522894aae25499a510af4ccb479063318d5e3a1543d85510a144ea56bc621e

data/Rakefile

@@ -26,7 +26,8 @@ task :run_browser do
   FileUtils.copy_entry('vendor/assets/src/css/', 'test/test_app/src/css/')
   FileUtils.copy_entry('vendor/assets/src/medias/', 'test/test_app/src/medias/')
   `gem cleanup atome;yes | gem uninstall atome ;gem build atome.gemspec;gem install atome`
-  `cd test/test_app;atome update;atome run`
+  `cd test/test_app;atome update;atome run compile`
+  puts 'atome browser is running'
 end
 
 
@@ -55,12 +56,16 @@ end
 
 task :run_example_server do
   FileUtils.copy_entry('vendor/assets/src/medias/rubies/examples/', 'test/test_app/src/medias/rubies/examples/')
-  `cd test/test_app;atome run server `
+  `cd test/test_app;atome run server`
 end
 
 
 task :taurification do
-  `cd test/test_app;cargo tauri dev  `
+  `cd test/test_app;cargo tauri dev`
+end
+
+task :osx do
+  `cd test/test_app;atome run osx guard`
 end
 
 

data/app_builder_helpers/Rakefile

@@ -57,10 +57,16 @@ def build_aui(user_project_path)
 end
 
 def copy_assets_files(user_project_path, gem_location)
-  build_location = "#{gem_location}/../vendor/assets/src/"
+  # build_location = "#{gem_location}/../vendor/assets/src/"
   server_location = "#{gem_location}/../vendor/assets/server/"
-  FileUtils.copy_entry build_location, "#{user_project_path}/src", preserve: nil
   FileUtils.copy_entry server_location, "#{user_project_path}/server", preserve: nil
+  # FileUtils.copy_entry build_location, "#{user_project_path}/src", preserve: nil
+  css_location ="#{gem_location}/../vendor/assets/src/css/"
+  FileUtils.copy_entry css_location, "#{user_project_path}/src/css", preserve: nil
+  js_location ="#{gem_location}/../vendor/assets/src/js/"
+  FileUtils.copy_entry js_location, "#{user_project_path}/src/js", preserve: nil
+  index_location ="#{gem_location}/../vendor/assets/src/index.html"
+  FileUtils.copy_entry index_location, "#{user_project_path}/src/index.html", preserve: nil
 end
 
 def build_atome_kernel(user_project_path, gem_location)

data/exe/atome

@@ -117,18 +117,20 @@ end
 
 def guard_check
   loop do
-    sleep 3
+    sleep 1
   end
   nil unless ARGV.include?('guard')
 end
 
 def browser_case(location)
-  `cd #{location}/src;open index.html`
+  # `cd #{location}/src;open index.html`
   guard_check
 end
 
+#
+
 def osx_case(location)
-  `cd #{location};cargo tauri dev  `
+  `cd #{location};cargo tauri dev`
 end
 
 def compile_case(location)
@@ -136,7 +138,6 @@ def compile_case(location)
   guard_check
 end
 
-
 def server_case(port, location)
   threads = []
   threads << Thread.new do
@@ -146,19 +147,6 @@ def server_case(port, location)
   `cd #{location}/server;rackup --server puma --port #{port}  --env production`
 end
 
-def test_native(build_target)
-  case build_target
-  when :freebsd
-    # freebsd
-  when :osx
-    # osx
-  when :windows
-    # windows
-  else
-    # freebsd
-  end
-end
-
 def run_case(build_target, location, port)
   case build_target
   when :server
@@ -170,10 +158,9 @@ def run_case(build_target, location, port)
   when :compile
     compile_case(location)
   when :native
-    test_native(build_target)
     # freebsd
   else
-    browser_case(location)
+    guard_check
   end
 end
 

data/lib/atome/atome.rb

@@ -8,7 +8,6 @@
 class Atome
   # TODO : clean or delete @private_atome
   include Essentials
-
   private
 
   def initialize(atomes = {}, &atomes_proc)
@@ -27,13 +26,13 @@ class Atome
     end
   end
 
-  def new_particle(element,store,render, &method_proc)
+  def new_particle(element, store, render, &method_proc)
     Atome.define_method element do |params = nil, &user_proc|
       if params || params == false
         # the line below execute the proc created when using the build_particle method
         instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
         params = sanitize(element, params)
-        create_particle(element,store,render)
+        create_particle(element, store, render)
         send("set_#{element}", params, &user_proc)
       else
         get_particle(element, &user_proc)
@@ -41,25 +40,37 @@ class Atome
     end
   end
 
-
-
-  def additional_particle_methods(element,store,render , &method_proc)
+  def additional_particle_methods(element, store, render, &method_proc)
     Atome.define_method "#{element}=" do |params = nil, &user_proc|
       instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
       params = sanitize(element, params)
-      particle_creation(element, params, store,render,&user_proc)
+      particle_creation(element, params, store, render, &user_proc)
     end
   end
 
-
   def atome_creation_pre_treatment(element, params, &user_proc)
     params = sanitize(element, params)
     create_atome(element)
     send("set_#{element}", params, &user_proc)
   end
 
+  def atome_initializer(element, params = {})
+    temp_default = Essentials.default_params[element] || {}
+    generated_render = params[:renderers] || []
+    generated_id = params[:id] || "#{element}_#{Universe.atomes.length}"
+    generated_parents = params[:parents] || [id.value]
+    generated_children = params[:children] || []
+    temp_default[:id] = generated_id
+    temp_default[:parents] = generated_parents
+    temp_default[:clones] = []
+    temp_default[:renderers] = generated_render
+    temp_default[:children] = generated_children
+    temp_default.merge(params)
+  end
+
   def new_atome(element, &method_proc)
     Atome.define_method element do |params = nil, &user_proc|
+
       if params
         instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
         atome_creation_pre_treatment(element, params, &user_proc)
@@ -78,14 +89,13 @@ class Atome
   end
 
   def run_optional_proc(proc_name, atome = self, element, &user_proc)
-    params=instance_variable_get("@#{element}")
+    params = instance_variable_get("@#{element}")
     option_found = Universe.get_optional_method(proc_name)
     atome.instance_exec(params, user_proc, atome, &option_found) if option_found.is_a?(Proc)
   end
 
-
   def store_value(element)
-    params=instance_variable_get("@#{element}")
+    params = instance_variable_get("@#{element}")
     @atome[element] = params
   end
 
@@ -93,14 +103,15 @@ class Atome
 
   # the line below is used for ephemera atomes
   attr_accessor :property, :value, :real_atome, :user_proc
-  attr_reader :atome, :structure#, :at_time
+  attr_reader :atome, :structure # , :at_time
 
   def set(value)
     @real_atome[@property] = value
   end
 
-  def particle_creation(element, params,store,render, &user_proc)
+  def particle_creation(element, params, store, render, &user_proc)
     return false unless security_pass(element, params)
+
     # we create a proc holder of any new particle if user pass a bloc
     store_code_bloc(element, &user_proc) if user_proc
     # Params is now an instance variable so it should be passed thru different methods
@@ -115,14 +126,12 @@ class Atome
     self
   end
 
-
-  def create_particle(element,store,render)
+  def create_particle(element, store, render)
     Atome.define_method "set_#{element}" do |params, &user_proc|
-      particle_creation(element, params, store,render,&user_proc)
+      particle_creation(element, params, store, render, &user_proc)
     end
   end
 
-
   def get(element)
     @atome[element]
   end
@@ -133,8 +142,8 @@ class Atome
     virtual_atome.real_atome = @atome
     virtual_atome.property = element
     virtual_atome.user_proc = user_proc
-    run_optional_proc("pre_get_#{@atome[:type]}".to_sym, "virtual_atome", &user_proc)
-    run_optional_proc("pre_get_#{element}".to_sym, self, "virtual_atome", &user_proc)
+    # run_optional_proc("pre_get_#{@atome[:type]}".to_sym, 'virtual_atome', &user_proc)
+    # run_optional_proc("pre_get_#{element}".to_sym, self, 'virtual_atome', &user_proc)
     virtual_atome
   end
 
@@ -145,6 +154,7 @@ class Atome
     virtual_atome.user_proc = user_proc
     virtual_atome.value = @atome[element]
     virtual_atome
+    "it should contain the atome not : #{element}"
   end
 
   def create_atome(new_atome)

data/lib/atome/extensions/atome.rb

@@ -1,4 +1,24 @@
 # frozen_string_literal: true
+def new(params, &bloc)
+  generator = Genesis.generator
+  if params.key?(:particle)
+    # render indicate if the particle needs to be rendered
+    # store tell the system if it need to store the particle value
+    # type help the system what type of type the particle will receive and store
+    generator.build_particle(params[:particle], { render: params[:render],
+                                                  store: params[:store], type: params[:type] }, &bloc)
+  elsif params.key?(:atome)
+    generator.build_atome(params[:atome], &bloc)
+  elsif params.key?(:sanitizer)
+    generator.build_sanitizer(params[:sanitizer], &bloc)
+  elsif params.key?(:pre)
+    generator.build_option("pre_render_#{params[:pre]}", &bloc)
+  elsif params.key?(:post)
+    generator.build_option("post_render_#{params[:post]}", &bloc)
+  elsif params.key?(:browser)
+    generator.build_render("browser_#{params[:browser]}", &bloc)
+  end
+end
 
 def grab(atome_to_get)
   Universe.atomes[atome_to_get]
@@ -18,7 +38,9 @@ end
 
 # the method below generate Atome method creation at Object level
 def create_method_at_object_level(element)
-  Object.define_method element do |params = nil, &user_proc|
+
+  Object.define_method element do |params, &user_proc|
     grab(:view).send(element, params, &user_proc)
   end
+
 end

data/lib/atome/extensions/matrix.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+#
 
-class Atome
+module Matrix
   def content(items = nil)
     if items.instance_of?(Array)
       items.each do |item|
@@ -172,11 +173,11 @@ class Atome
         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}"
+        # puts "===> #{current_cell}"
         current_cell.children.each do |child|
-          puts "=>#{cell_width}"
-          grab(child).width(cell_width)
-          grab(child).height(cell_width)
+          # puts "=>#{cell_width}"
+          grab(child).width(cell_width) if grab(child)
+          grab(child).height(cell_width) if grab(child)
         end
         current_cell.width = cell_width
         current_cell.height = cell_height
@@ -399,3 +400,7 @@ class Atome
     end
   end
 end
+
+class Atome
+  include Matrix
+end

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

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 
-generator = Genesis.generator
-
-generator.build_atome(:animation)
-generator.build_atome(:color)
-generator.build_sanitizer(:color) do |params|
+new({ atome: :color })
+new({ sanitizer: :color }) do |params|
   parent_found = found_parents_and_renderers[:parent]
-  parent_found = [:user_view] if parent_found == [:view]
+  parent_found = [:black_matter] 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,
@@ -16,17 +13,32 @@ generator.build_sanitizer(:color) do |params|
   atome[:color] = new_params
   new_params
 end
-
-generator.build_sanitizer(:video) do |params|
+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
+    params = { path: "./medias/images/#{params}" }
+  end
+  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)
+  params
+end
+new({ atome: :video })
+new({ sanitizer: :video }) do |params|
   parent_found = found_parents_and_renderers[:parent]
   render_found = found_parents_and_renderers[:renderers]
   default_params = { renderers: render_found, id: "video_#{Universe.atomes.length}", type: :video,
                      parents: parent_found }
   default_params.merge!(params)
 end
-generator.build_atome(:shadow)
-
-generator.build_sanitizer(:shadow) do |params|
+new({ atome: :shadow })
+new({ 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]
@@ -35,20 +47,135 @@ generator.build_sanitizer(:shadow) do |params|
                      red: 0, green: 0, blue: 0, alpha: 1, blur: 3, left: 3, top: 3 }
   default_params.merge!(params)
 end
-generator.build_atome(:shape)
-generator.build_atome(:text)
-generator.build_atome(:image)
-generator.build_atome(:video)
-generator.build_atome(:code)
-generator.build_atome(:audio)
-generator.build_atome(:element)
-generator.build_atome(:web)
-generator.build_sanitizer(:element) do |params|
+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 = []
   default_params = { renderers: render_found, id: "element_#{Universe.atomes.length}", type: :element,
-                     parents: parent_found }
+                     parents: parent_found, 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] || "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)
+  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] || "#{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)
+  params
+end
+new({ atome: :text })
+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] || "#{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)
+  params
+end
+
 
-generator.build_atome(:collector)
+# generator = Genesis.generator
+#
+# generator.build_atome(:animation)
+# generator.build_atome(:color)
+# generator.build_sanitizer(:color) do |params|
+#   parent_found = found_parents_and_renderers[:parent]
+#   parent_found = [:black_matter] 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,
+#                      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
+#   new_params
+# end
+#
+# generator.build_atome(:video)
+# generator.build_sanitizer(:video) do |params|
+#   parent_found = found_parents_and_renderers[:parent]
+#   render_found = found_parents_and_renderers[:renderers]
+#   default_params = { renderers: render_found, id: "video_#{Universe.atomes.length}", type: :video,
+#                      parents: parent_found }
+#   default_params.merge!(params)
+# end
+# 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 }
+#   default_params.merge!(params)
+# end
+# generator.build_atome(:shape)
+# generator.build_atome(:text)
+# generator.build_atome(:code)
+# generator.build_atome(:audio)
+# generator.build_atome(:element)
+# generator.build_sanitizer(:element) do |params|
+#   parent_found = found_parents_and_renderers[:parent]
+#   render_found = []
+#   default_params = { renderers: render_found, id: "element_#{Universe.atomes.length}", type: :element,
+#                      parents: parent_found, data: '' }
+#   default_params.merge!(params)
+# end
+# generator.build_atome(:collector)
+# generator.build_atome(:web)
+# generator.build_sanitizer(:web) do |params|
+#   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)
+#   params
+# end
+# generator.build_sanitizer(:animation) do |params|
+#   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)
+#   params
+# end
+# generator.build_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] || "#{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)
+#   params
+# end

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

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
-generator = Genesis.generator
 
-generator.build_particle(:smooth)
-generator.build_particle(:blur)
+new({ particle: :smooth })
+new({ particle: :blur })
+
+
+# generator = Genesis.generator
+#
+# generator.build_particle(:smooth)
+# generator.build_particle(:blur)

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

@@ -1,50 +1,93 @@
 # frozen_string_literal: true
 
-generator = Genesis.generator
 
-# touch
-generator.build_particle(:touch)
-# video
-generator.build_particle(:play) do
+
+new({particle: :touch })
+new({particle: :play }) do
   @atome[:pause] = :false
 end
-generator.build_particle(:time)
-generator.build_particle(:pause) do
+new({particle: :time })
+new({particle: :pause }) do
   @atome[:play] = :false
 end
-generator.build_particle(:on)
-generator.build_particle(:fullscreen)
-generator.build_particle(:mute)
-# TODO : add the at event to ny particle : (width, left, ...) maybe use monitor particle
-# generator.build_particle(:at)
-# drag
-generator.build_particle(:drag)
-generator.build_sanitizer(:drag) do |params|
+new({particle: :on })
+new({particle: :fullscreen })
+new({particle: :mute })
+new({particle: :drag })
+new({ sanitizer: :drag }) do |params|
   params = { move: true } if params == true
   params
 end
-# sort
-generator.build_particle(:sort) do |_value, sort_proc|
+new({particle: :sort }) do |_value, sort_proc|
   @sort_proc = sort_proc
 end
-
-# animation
-generator.build_particle(:targets)
-generator.build_particle(:start)
-generator.build_option(:pre_render_start) do |_value, user_proc|
+new({particle: :targets })
+new({particle: :start })
+new({pre: :start }) do |_value, user_proc|
   @animation_start_proc = user_proc
 end
-generator.build_particle(:stop)
-generator.build_option(:pre_render_stop) do |_value, user_proc|
+new({particle: :stop })
+new({pre: :stop })  do |_value, user_proc|
   @animation_stop_proc = user_proc
 end
-generator.build_particle(:begin)
-generator.build_particle(:end)
-generator.build_particle(:duration)
-generator.build_particle(:mass)
-generator.build_particle(:damping)
-generator.build_particle(:stiffness)
-generator.build_particle(:velocity)
-generator.build_particle(:repeat)
-generator.build_particle(:ease)
-generator.build_particle(:unbind)
+new({particle: :begin })
+new({particle: :end })
+new({particle: :duration })
+new({particle: :mass })
+new({particle: :damping })
+new({particle: :stiffness })
+new({particle: :velocity })
+new({particle: :repeat })
+new({particle: :ease })
+new({particle: :unbind })
+new({particle: :over })
+
+
+# generator = Genesis.generator
+#
+# # touch
+# generator.build_particle(:touch)
+# # video
+# generator.build_particle(:play) do
+#   @atome[:pause] = :false
+# end
+# generator.build_particle(:time)
+# generator.build_particle(:pause) do
+#   @atome[:play] = :false
+# end
+# generator.build_particle(:on)
+# generator.build_particle(:fullscreen)
+# generator.build_particle(:mute)
+# # TODO : add the at event to ny particle : (width, left, ...) maybe use monitor particle
+# # generator.build_particle(:at)
+# # drag
+# generator.build_particle(:drag)
+# generator.build_sanitizer(:drag) do |params|
+#   params = { move: true } if params == true
+#   params
+# end
+# # sort
+# generator.build_particle(:sort) do |_value, sort_proc|
+#   @sort_proc = sort_proc
+# end
+# # animation
+# generator.build_particle(:targets)
+# generator.build_particle(:start)
+# generator.build_option(:pre_render_start) do |_value, user_proc|
+#   @animation_start_proc = user_proc
+# end
+# generator.build_particle(:stop)
+# generator.build_option(:pre_render_stop) do |_value, user_proc|
+#   @animation_stop_proc = user_proc
+# end
+# generator.build_particle(:begin)
+# generator.build_particle(:end)
+# generator.build_particle(:duration)
+# generator.build_particle(:mass)
+# generator.build_particle(:damping)
+# generator.build_particle(:stiffness)
+# generator.build_particle(:velocity)
+# generator.build_particle(:repeat)
+# generator.build_particle(:ease)
+# generator.build_particle(:unbind)
+# generator.build_particle(:over)