atome 0.5.3.2 → 0.5.3.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3b3eb14241b108a8fff26a1d336211199a4cf7a133069e399383f8c590be948
-  data.tar.gz: 4bab390e92b2b65a180a2537902ca68bbb7a78faed8debf8cbf2e05063647b7f
+  metadata.gz: 949a07eee4e8a4e64c796c8c03b4f38ce5e8681db043ae498dc0d6dd1f48ab8f
+  data.tar.gz: 32816c3ee8e8ad508f87e49ea84213df1ed3d486f9a162d82d0f14f0ad71dd71
 SHA512:
-  metadata.gz: 71670c634ee463c0de14a00749d760174831029b1c6e45df1cb4fd6101ea51f083ff4c895d35a93de28a472bb63feb40ee23cd5c27d12f56571f62e6276654e6
-  data.tar.gz: def487b5d20de25b4c112d65d850d94a454651750dfc240a329128b3cfbd42088bb391c29667f7de65297da2ed65bda55dea446ff436580bd3195891818c7947
+  metadata.gz: 5c1f9a2bf45e6094d76aa2574361958b9a8e40c2a76c1ad60fd48a8e15823898c949a37198757387af509fbe5ec61a1c3ff8d88adf51b5a69ccf5d435bad7605
+  data.tar.gz: 31c7c58e7cd2512875a71d3d65318a318737138a376a7169e3998d3a33e3f5a94ce80fcbbeec36f71234da4bf091dbd2c3e696320f8aa6755682ae2829273764

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

@@ -4,7 +4,7 @@
 
 require 'opal'
 # require 'opal-jquery'
-require 'opal-browser'
+require 'atome-opal-browser'
 require 'parser'
 # require 'ruby2js'
 require 'uglifier'
@@ -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,22 +117,27 @@ 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`
+end
+
 def compile_case(location)
   `cd #{location}/src`
   guard_check
 end
 
-
 def server_case(port, location)
   threads = []
   threads << Thread.new do
@@ -142,32 +147,20 @@ 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
     server_case(port, location)
   when :browser
     browser_case(location)
+  when :osx
+    osx_case(location)
   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,8 +1,9 @@
 # frozen_string_literal: true
+#
 
-class Atome
+module Matrix
   def content(items = nil)
-    if  items.instance_of?(Array)
+    if items.instance_of?(Array)
       items.each do |item|
         content(item)
       end
@@ -19,18 +20,17 @@ class Atome
       @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])
+      items.parents([id])
     else
       @cell_content
     end
-
   end
 
   def cells(cell_nb)
     collector_object = collector({})
     collected_atomes = []
     cell_nb.each do |cell_found|
-      atome_found = grab ("#{id}_#{cell_found}")
+      atome_found = grab("#{id}_#{cell_found}")
       collected_atomes << atome_found
     end
     collector_object.data(collected_atomes)
@@ -38,8 +38,7 @@ class Atome
   end
 
   def cell(cell_nb)
-    cell_found = grab ("#{id}_#{cell_nb}")
-    cell_found
+    grab("#{id}_#{cell_nb}")
   end
 
   def columns(column_requested, &proc)
@@ -81,7 +80,7 @@ class Atome
         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
+          if index.zero?
             current_cell.height(cell_height * cells_to_alter.length + @margin * (cells_to_alter.length - 1))
           else
             current_cell.hide(true)
@@ -97,7 +96,7 @@ class Atome
 
         cells_to_alter.each_with_index do |cell_nb, index|
           current_cell = grab("#{id.value}_#{cell_nb}")
-          if index == 0
+          if index.zero?
             current_cell.width(cell_width * cells_to_alter.length + @margin * (cells_to_alter.length - 1))
           else
             current_cell.hide(true)
@@ -105,7 +104,6 @@ class Atome
         end
       end
     end
-
   end
 
   def divide(params)
@@ -141,7 +139,6 @@ class Atome
         end
       end
     end
-
   end
 
   # def override(params)
@@ -168,7 +165,7 @@ class Atome
   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
+    ratio = cell_height / cell_width
     i = 0
     nb_of_rows.times do |row_index|
       nb_of_cols.times do |col_index|
@@ -176,14 +173,14 @@ 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
+        current_cell.width = cell_width
+        current_cell.height = cell_height
         current_cell.left(x)
         current_cell.top(y)
         i += 1
@@ -194,43 +191,52 @@ class Atome
 
     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
+    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)
-
-    if  params[:columns]
-      columns_data = params.delete(:columns)
-    else
-      columns_data= {  count: 4 }
-    end
-
-    if  params[:rows]
-      rows_data = params.delete(:rows)
-    else
-      rows_data= {  count: 4 }
-    end
-
-    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
+    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]
@@ -251,12 +257,12 @@ class Atome
     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('@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]
@@ -279,7 +285,6 @@ class Atome
                      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,
@@ -291,9 +296,8 @@ class Atome
         columns_fusion: {},
         columns_divided: {},
         rows_fusion: {},
-        rows_divided: {},
+        rows_divided: {}
       }
-      the_matrix.instance_variable_set("@exceptions", exceptions)
       # @exceptions = {
       #   columns_fusion: {},
       #   columns_divided: {},
@@ -301,6 +305,7 @@ class Atome
       #   rows_divided: {},
       # }
     end
+    the_matrix.instance_variable_set('@exceptions', exceptions)
 
     # let's create the matrix background
     # current_matrix = grab(:view).box({ id: matrix_id })
@@ -310,7 +315,7 @@ class Atome
     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])
+      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])
@@ -330,10 +335,10 @@ class Atome
         # puts index
         #
       end
-      current_cell = self.box({ id: "#{id}_#{index}" })
+      current_cell = box({ id: "#{id}_#{index}" })
       apply_style(current_cell, @cell_style)
     end
-    @columns = @columns + nb
+    @columns += nb
     ########## old algo
     # nb_of_cells_to_adds = nb * @rows
     # prev_nb_of_cells = @columns * @rows
@@ -355,10 +360,10 @@ class Atome
         # puts index
         #
       end
-      current_cell = self.box({ id: "#{id}_#{index}" })
+      current_cell = box({ id: "#{id}_#{index}" })
       apply_style(current_cell, @cell_style)
     end
-    @rows = @rows + nb
+    @rows += nb
     ########## old algo
     # nb_of_cells_to_adds = nb * @columns
     # prev_nb_of_cells = @columns * @rows
@@ -387,12 +392,15 @@ class Atome
       (0...num_rows).each do |row|
         result << (index + row * num_columns)
       end
-      return result
+      result
     else
       start_index = index * num_columns
       end_index = start_index + num_columns - 1
-      return (start_index..end_index).to_a
+      (start_index..end_index).to_a
     end
   end
+end
 
+class Atome
+  include Matrix
 end