atome 0.5.7.3.9 → 0.5.7.4.2

data/lib/atome/presets/atome.rb

@@ -13,15 +13,10 @@ class Atome
     # TODO : remove Essentials.default_params[atome_preset] || {} as it is
     # applied twice because preset is now a particle
     preset_params = Essentials.default_params[atome_preset] || {}
-    # preset_params =  {preset: atome_preset}
     basic_params[:type] = preset_params[:type] || :element
-    # basic_params[:aid] =  identity_generator(:a)
-    # alert "common =>  #{params[:id]}"
-    # alert "basic_params  #{basic_params[:id].class}"
     basic_params[:id] = params[:id] || identity_generator
     basic_params[:renderers] = @renderers || preset_params[:renderers]
     essential_params = basic_params.merge(preset_params)
-    #
     reordered_params = essential_params.reject { |key, _| params.has_key?(key) }
     params = reordered_params.merge(params)
     params[:id] = params[:id].to_sym
@@ -45,23 +40,6 @@ class Atome
     Atome.new(params, &bloc)
   end
 
-  # def box(params = {}, &bloc)
-  #   atome_preset = :box
-  #   params = atome_common(atome_preset, params)
-  #   preset_common(params, &bloc)
-  # end
-  #
-  # # def intuition(params = {}, &bloc)
-  # #   atome_preset = :intuition
-  # #   params = atome_common(atome_preset, params)
-  # #   preset_common(params, &bloc)
-  # # end
-  #
-  # def circle(params = {}, &bloc)
-  #   atome_preset = :circle
-  #   params = atome_common(atome_preset, params)
-  #   preset_common(params, &bloc)
-  # end
 end
 
 

data/lib/atome/version.rb

@@ -3,5 +3,5 @@
 #  return atome version
 
 class Atome
-  VERSION = '0.5.7.3.9'
+  VERSION = '0.5.7.4.2'
 end

data/lib/molecules/init.rb

@@ -6,10 +6,6 @@ end
 
 class Object
   include Molecule
-  # we add a getter for the molecule in standard ruby Object
-  # def molecule
-  #   @molecule
-  # end
 end
 
 class Atome
@@ -17,15 +13,5 @@ class Atome
 end
 
 
-# tests
-# new({application: :compose, header: true, footer: true })
-#
-# new(page: {name: :home, application: :compose, attach: :root })
-#
-# new(module: {name: :home, application: :compose, attach: :root })
-
-
-
-
 
 

data/lib/molecules/intuition/tools.rb

@@ -67,11 +67,9 @@ class Atome
                 atome_found = grab(id_found)
                 # unless (atome_found && atome_found.tag[:system])
                 puts 'we have to check if operation is a creation or an alteration to include or exclude the view '
-                # alert atome_touched
                 Universe.active_tools.each do |tool|
-                  # alert "#{tool}, #{atome_found.id}"
                   apply_tool(tool, atome_found, event)
-                end # if atome_found #&& !atome_found.tag[:system]
+                end
 
                 break
               end
@@ -122,8 +120,6 @@ class Atome
     end
 
     def creation(current_tool, tool_actions, atome_touched, a_event)
-      # we store prev_local_storage prior to lock it to prevent unwanted logs
-      # prev_local_storage=Universe.allow_localstorage()
       @creation_mode = true
       storage_allowed = Universe.allow_localstorage
       Universe.allow_localstorage = false
@@ -142,7 +138,6 @@ class Atome
                       else
                         grab(:view).send(atome, temp_val)
                       end
-          # current_tool.data[:treated] << new_atome
           current_tool.data[:created] << new_atome
           params.delete(:atome_touched)
           params[new_atome: new_atome]
@@ -174,9 +169,7 @@ class Atome
                else
                  atome_touched
                end
-      # unless method_found == :alteration && (target.id == :view_color || target.id == :view)
-        unless method_found == :alteration && target.tag[:system]
-
+      unless method_found == :alteration && target.tag[:system]
 
         tools_scheme[:particles]&.each do |particle_f, value_f|
           target.send(particle_f, value_f)
@@ -220,7 +213,6 @@ class Atome
     tool.data[:created] = []
     tool.data[:prev_states] = {}
     # generic behavior
-    # tool.apply(:active_tool_col)
     grab("#{tool_name}_icon").color(:white)
     grab("#{tool_name}_label").color(:white)
     Universe.active_tools << tool_name
@@ -251,8 +243,7 @@ class Atome
         Atome.apply_tool(tool_name, atome_found, event)
       end
     end
-
-    # # activate tool analysis test
+    # activate tool analysis test
     Atome.activate_click_analysis
     tool.active(true)
   end
@@ -284,7 +275,6 @@ class Atome
     # generic behavior
     # we remove touch and resize binding on newly created atomes
     tool.apply(:inactive_tool_col)
-    # alert tool.data[:created]
     tool.data[:created]&.each do |new_atome|
       new_atome.drag(false)
       new_atome.resize(:remove)
@@ -299,7 +289,6 @@ class Atome
     tool_name = "#{params[:name]}_tool"
     index = params[:index]
     tool_scheme = params[:scheme]
-    # @tool_scheme=params[:scheme]
     toolbox = params[:toolbox] || {}
     orientation_wanted = tool_scheme[:orientation] || :sn
 
@@ -351,8 +340,6 @@ class Atome
                                           action: action,
                                           allow_alteration: true,
                                           allow_creation: true,
-                                          # activation: tool_scheme[:activation],
-                                          #  inactivation: tool_scheme[:inactivation], zone: tool_scheme[:zone],
                                           post: tool_scheme[:post],
                                           pre: tool_scheme[:pre],
                                   }
@@ -421,8 +408,6 @@ class Atome
             if particle.instance_variable_get('@active')
               grab(slider_id).delete({ force: true })
               particle.instance_variable_set('@active', false)
-              # particle.top(:auto)
-              # particle.top(:bottom)
               particle.height(size)
               particle.top(0)
             else
@@ -446,9 +431,7 @@ class Atome
                 if grab(slider_id).instance_variable_get('@initialised')
                   Atome.selection.each do |atome_id_to_treat|
 
-                    # puts "-------> #{tool_scheme[:particles][particle_name]} , #{value }"
                     tool_scheme[:particles][particle_name] = value.to_f / 100
-                    # tools_scheme[:particles]
                     atome_found = grab(atome_id_to_treat)
                     target = grab(atome_found.color.last)
 
@@ -495,10 +478,8 @@ class Atome
           tick[tool_name] = 0
         end
       end
-      # puts 'reactivation'
       tool.instance_variable_set('@prevent_action', false)
     end
-
   end
 
 end

data/lib/molecules/intuition/utilities.rb

@@ -1,11 +1,36 @@
 # frozen_string_literal: true
 
 class Atome
+  def reorder_menu
+    disposition = data[:inactive][:disposition]
+    margin = data[:inactive][:margin]
+    spacing = data[:inactive][:spacing]
+    inactive_style = data[:inactive]
+    keys_to_exclude = [:margin, :spacing, :disposition, :text]
+    inactive_style = inactive_style.reject { |key, _| keys_to_exclude.include?(key) }
+    fasten.each_with_index do |atome_f, index|
+      menu_item = grab(atome_f)
+      if disposition == :horizontal
+        menu_item.left = margin[:left] + (inactive_style[:width] + spacing) * index
+        menu_item.top = margin[:top]
+      else
+        menu_item.top = margin[:top] + (inactive_style[:height] + spacing) * index
+        menu_item.left = margin[:left]
+      end
+    end
+  end
+
+  def remove_menu_item(item_to_remove)
+    grab(item_to_remove).delete(recursive: true)
+    reorder_menu
+  end
 
   def create_new_button(button_id, position_in_menu, label, code)
     essential_keys = [:inactive, :active]
-    buttons_style = data.select { |key, value| essential_keys.include?(key) }
+    buttons_style = data.select { |key, _value| essential_keys.include?(key) }
     menu_item = box({ id: button_id })
+    actor({ button_id => :button })
+    menu_item.role(:button)
     menu_item.text({ data: label, id: "#{button_id}_label" })
     menu_item.code({ button_code: code })
 
@@ -14,6 +39,7 @@ class Atome
     if active_style
       active_state_text = active_style[:text]
       keys_to_exclude = [:margin, :spacing, :disposition, :text]
+
       active_style = active_style.reject { |key, _| keys_to_exclude.include?(key) }
     end
 
@@ -26,6 +52,7 @@ class Atome
       inactive_style = inactive_style.reject { |key, _| keys_to_exclude.include?(key) }
       menu_item.set(inactive_style)
 
+      # reorder_menu
       if disposition == :horizontal
         menu_item.left = margin[:left] + (inactive_style[:width] + spacing) * position_in_menu
         menu_item.top = margin[:top]
@@ -42,29 +69,33 @@ class Atome
 
     menu_item.touch(:down) do
       unless @active_item == menu_item.id
-        menu_item.set(active_style)
+
         menu_item.text.each do |text_f|
-          grab(text_f).set(active_state_text)
-        end
-        fasten.each do |item_id|
-          unless button_id == item_id
-            grab(item_id).remove({ all: :shadow })
-            grab(item_id).set(inactive_style)
-            grab("#{item_id}_label").remove({ all: :shadow })
-            grab("#{item_id}_label").set(inactive_state_text)
+          # below we unset any active style
+          fasten.each do |item_id|
+            unless button_id == item_id
+              grab(item_id).remove({ all: :shadow })
+              grab(item_id).set(inactive_style)
+              grab("#{item_id}_label").remove({ all: :shadow })
+              grab("#{item_id}_label").set(inactive_state_text)
+            end
+            grab(text_f).set(active_state_text)
           end
+
         end
-        code.call if code
+        menu_item.set(active_style)
+        code&.call
+        @active_item = menu_item.id
       end
-      @active_item = menu_item.id
+
     end
+
   end
 
   def add_button(params)
     params.each do |button_id, params|
       label = params[:text]
       code = params[:code]
-      # {"new_button"=>{"text"=>"button1", "code"=>#<Proc:0xafe>}}
       index = fasten.length
       create_new_button(button_id, index, label, code)
     end
@@ -72,7 +103,6 @@ class Atome
   end
 
   def resize_matrix(params)
-
     width(params[:width])
     height(params[:height])
     current_matrix = self
@@ -106,14 +136,12 @@ class Atome
     end
 
   end
-
 end
 
 new(molecule: :input) do |params, bloc|
   params[:height] ||= 15
   params[:width] ||= 222
   new_id = params.delete(:id) || identity_generator
-
   trigger = params.delete(:trigger)
   trigger ||= :return
   limit = params.delete(:limit)
@@ -124,8 +152,6 @@ new(molecule: :input) do |params, bloc|
   text_params ||= {}
   default_text = params.delete(:default)
   component = params.delete(:component)
-  # component ||= {}
-
   default_text ||= :input
   default_parent = if self.instance_of?(Atome)
                      id
@@ -146,44 +172,33 @@ new(molecule: :input) do |params, bloc|
       position: :absolute
     }.merge(text_params)
   )
-  # text_input.set()
   text_input.touch(:down) do
     input_back.tick(:input)
     text_input.edit(true)
   end
 
   input_back.touch(:up) do
-    if input_back.tick[:input] == 1
-      text_input.component({ selected: true })
-    end
+    text_input.component({ selected: true }) if input_back.tick[:input] == 1
   end
 
   text_input.keyboard(:down) do |native_event|
-    # text_input.component({ selected: { color: :red, text: :red } })
-
     event = Native(native_event)
     if event[:keyCode].to_s == '8' || event[:keyCode].to_s == '46'
       # always allow
     elsif event[:keyCode].to_s == '13'
       # we prevent the input
-      if trigger == :return
-        bloc.call(text_input.data)
-      end
+      bloc.call(text_input.data) if trigger == :return
       text_input.edit(false)
       event.preventDefault()
     elsif text_input.data.length > limit
       event.preventDefault()
     end
-    if trigger == :down
-      bloc.call(text_input.data)
-    end
+    bloc.call(text_input.data) if trigger == :down
   end
 
-  text_input.keyboard(:up) do |native_event|
+  text_input.keyboard(:up) do |_native_event|
     input_back.data = text_input.data
-    if trigger == :up
-      bloc.call(text_input.data)
-    end
+    bloc.call(text_input.data) if trigger == :up
   end
   params.each do |part_f, val_f|
     input_back.send(part_f, val_f)
@@ -193,13 +208,11 @@ new(molecule: :input) do |params, bloc|
 end
 
 new(molecule: :list) do |params, _bloc|
-
   styles_found = params.delete(:styles)
   element = params.delete(:element)
   listing = params.delete(:listing)
   action = params.delete(:action)
   new_id = params.delete(:id) || identity_generator
-
   styles_found ||= {
     width: 99,
     height: 33,
@@ -214,12 +227,8 @@ new(molecule: :list) do |params, _bloc|
                 top: :center,
                 color: :orange,
                 type: :text }
-  unless params[:width]
-    params[:width] = styles_found[:width]
-  end
-  unless element[:width]
-    element[:width] = styles_found[width]
-  end
+  params[:width] = styles_found[:width] unless params[:width]
+  element[:width] = styles_found[width] unless element[:width]
   margin = styles_found[:margin]
   height_found = styles_found[:height]
 
@@ -475,22 +484,59 @@ new(molecule: :application) do |params, &bloc|
          else
            identity_generator
          end
+
   main_app = box({ id: id_f, width: :auto, height: :auto, top: 0, bottom: 0, left: 0, right: 0, apply: :app_color,
                    category: :application })
   main_app.remove(:box_color)
   main_app.instance_variable_set('@pages', {})
+  main_app.role(:application)
+
+  menu = buttons({
+                   id: "#{id_f}_menu",
+                   attach: id_f,
+                   inactive: { text: { color: :gray }, width: 66, height: 12, spacing: 3, disposition: :horizontal,
+                               color: :orange, margin: { left: 33, top: 12 } },
+                   active: { text: { color: :white, shadow: {} }, color: :blue, shadow: {} },
+                 })
+  main_app.define_singleton_method(:menu) do
+    menu
+  end
+  main_app.define_singleton_method(:pages) do
+    @pages
+  end
+
+  main_app.define_singleton_method(:insert) do |bloc_to_add|
+    bloc_to_add.each do |page_id, params_f|
+      params_f.each do |block_id, block_content|
+        @pages[page_id][:blocks] ||= {}
+        @pages[page_id][:blocks][block_id.to_sym] = block_content
+      end
+      @blocks ||= {}
+      @blocks[page_id] = @pages[page_id][:blocks]
+    end
+
+  end
+  main_app.define_singleton_method(:extract) do |bloc_to_extract|
+    bloc_to_extract.each do |page_id, block_id|
+      @blocks[page_id].delete(block_id)
+    end
+
+  end
+
+  main_app.define_singleton_method(:blocks) do
+    @blocks
+  end
+  main_app.define_singleton_method(:margin) do
+    @margin = params[:margin]
+  end
+  main_app.define_singleton_method(:spacing) do
+    @spacing = params[:spacing]
+  end
 
-  buttons({
-            id: "#{id_f}_menu",
-            attach: id_f,
-            inactive: { text: { color: :gray }, width: 66, height: 12, spacing: 3, disposition: :horizontal,
-                        color: :orange, margin: { left: 33, top: 12 } },
-            active: { text: { color: :white, shadow: {} }, color: :blue, shadow: {} },
-          })
   main_app
 end
 
-new(molecule: :page) do |params, &bloc|
+new(molecule: :page) do |params = nil, &bloc|
   allow_menu = params.delete(:menu)
   if params[:id]
     id_f = params.delete(:id)
@@ -510,35 +556,44 @@ new(molecule: :page) do |params, &bloc|
       code: item_code
     } })
     actor({ "#{@id}_menu_item_#{page_name}" => :buttons })
-    menu_f.role([:button])
   end
 end
 
 new(molecule: :show) do |page_id, &bloc|
+
   params = @pages[page_id.to_sym]
   params ||= {}
   footer = params.delete(:footer)
   header = params.delete(:header)
   left_side_bar = params.delete(:left_side_bar)
   right_side_bar = params.delete(:right_side_bar)
-  # modules = params.delete(:modules)
   basic_size = 30
   fasten.each do |page_id_found|
     page_found = grab(page_id_found)
-    page_found.delete({ recursive: true }) if page_found && page_found.category.include?(:page)
+    page_found.delete({ recursive: true }) if page_found&.category&.include?(:page)
   end
   color({ id: :page_color, red: 0.1, green: 0.1, blue: 0.1 })
-  # TODO : remove the patch below when possible
-  id_f = if params[:id]
-           params.delete(:id)
-         else
-           "#{id_f}_#{identity_generator}"
-         end
+
+  id_f = "#{id}_content"
   main_page = box({ width: :auto, depth: -1, height: :auto, id: id_f, top: 0, bottom: 0, left: 0, right: 0, apply: :page_color, category: :page })
   main_page.remove(:box_color)
 
-  main_page.set(params)
+  new_page = main_page.box({ width: '100%', height: '100%', top: 0, left: 0, id: page_id })
+
+  # now looking for associated blocks
+  blocks_found = params[:blocks]
+  @prev_bloc_height = 0
+  blocks_found&.each_with_index do |(bloc_id, bloc_content), index|
+
+    new_bloc = new_page.box({ id: bloc_id, width: '100%', height: 99, top: spacing + @prev_bloc_height, bottom: 0, left: 0, right: 0 })
+    new_bloc.set(bloc_content)
+    @prev_bloc_height = @prev_bloc_height + new_bloc.height + spacing
+  end
 
+  keys_to_exclude = [:blocks]
+  particles_to_apply = params.reject { |key, _| keys_to_exclude.include?(key) }
+
+  new_page.set(particles_to_apply)
   if footer
     new_footer = box({ left: 0, depth: -1, right: 0, width: :auto, top: :auto, bottom: 0, height: basic_size, category: :footer, id: "#{id_f}_footer" })
     new_footer.remove(:box_color)
@@ -577,23 +632,15 @@ new(molecule: :show) do |page_id, &bloc|
     if item_found&.category&.include?(:right_side_bar)
       main_page.width(:auto)
       main_page.left(item_found.width)
-      if footer
-        grab("#{id_f}_footer").right(basic_size)
-      end
-      if header
-        grab("#{id_f}_header").right(basic_size)
-      end
+      grab("#{id_f}_footer").right(basic_size) if footer
+      grab("#{id_f}_header").right(basic_size) if header
     end
 
     if item_found&.category&.include?(:left_side_bar)
       main_page.width(:auto)
       main_page.right(item_found.width)
-      if footer
-        grab("#{id_f}_footer").left(basic_size)
-      end
-      if header
-        grab("#{id_f}_header").left(basic_size)
-      end
+      grab("#{id_f}_footer").left(basic_size) if footer
+      grab("#{id_f}_header").left(basic_size) if header
     end
   end
   main_page
@@ -604,8 +651,8 @@ new(molecule: :buttons) do |params, &bloc|
   actor_f = params.delete(:actor)
   params_saf = deep_copy(params)
   context = params.delete(:attach) || :view
-  id = params.delete(:id) || identity_generator
-  main = grab(context).box({ id: id })
+  id_f = params.delete(:id) || identity_generator
+  main = grab(context).box({ id: id_f })
   main.role(role_f) || main.role(:buttons)
   main.actor(actor_f) if actor_f
   main.color({ blue: 0.5, red: 1, green: 1, alpha: 0 })
@@ -615,7 +662,6 @@ new(molecule: :buttons) do |params, &bloc|
   default_text = default.delete(:text)
   main.data[:default_text] = default_text
   active = params.delete(:active) || {}
-  active_text = active.delete(:text)
   inactive = {}
   active.each_key do |part_f|
     inactive[part_f] = default[part_f]
@@ -624,12 +670,10 @@ new(molecule: :buttons) do |params, &bloc|
   active.each_key do |part_f|
     inactive_text[part_f] = default_text[part_f]
   end
-
   params.each_with_index do |(item_id, part_f), index|
     label = part_f[:text]
     code = part_f[:code]
     main.create_new_button(item_id, index, label, code)
-
   end
   main
 

data/lib/platform_specific/opal/atome_opal_extensions.rb

@@ -4,7 +4,6 @@ require 'extensions/object'
 require 'extensions/js'
 require 'extensions/geolocation'
 require 'extensions/ping'
-require 'extensions/sha'
 require 'extensions/color'
 require 'native'
 require 'promise'

data/lib/platform_specific/opal/extensions/color.rb

@@ -3,11 +3,6 @@
 # rgb utility
 class Atome
   def rgb_html(string)
-    #    `
-    #  col = w3color(#{string});
-    #  rgb_col=col.toRgb();
-    #  return Opal.hash(rgb_col)
-    # `
     js_code = <<-JS
   var col = w3color('#{string}');
   var rgb_col = col.toRgb();

data/lib/platform_specific/opal/extensions/geolocation.rb

@@ -2,13 +2,13 @@
 
 class Atome
   def geolocation
-    localisation = {latitude: nil, longitude: nil}
+    localisation = { latitude: nil, longitude: nil }
     $window.navigator.geolocate.then do |pos|
-      localisation[:latitude] =  pos.coords.latitude
-      localisation[:longitude] =  pos.coords.longitude
+      localisation[:latitude] = pos.coords.latitude
+      localisation[:longitude] = pos.coords.longitude
     end.rescue do |err|
-      p  err
-      localisation = nil
+      p err
+      nil
     end
   end
 end

data/lib/platform_specific/opal/extensions/ping.rb

@@ -4,28 +4,19 @@
 class Atome
   def ping(my_proc = false)
     instance_exec(my_proc) if my_proc.is_a?(Proc)
-#     ` var p = new Ping();
-#         p.ping('https://'+#{address}+'', function (err, data) {
-#             if (err) {
-#                return false;
-#             } else {
-#  console.log("the site "+#{address}+" is up!");
-#             }
-#         });
-# `
-    js_code = <<-JS
-var p = new Ping();
-p.ping('https://' + "#{address}" + '', function (err, data) {
-    if (err) {
-       return false;
-    } else {
-       console.log("the site " + "#{address}" + " is up!");
-    }
-});
-JS
+
+    js_code = <<~JS
+      var p = new Ping();
+      p.ping('https://' + "#{address}" + '', function (err, data) {
+          if (err) {
+             return false;
+          } else {
+             console.log("the site " + "#{address}" + " is up!");
+          }
+      });
+    JS
 
     # Exécute le code JavaScript
     JS.eval(js_code)
-
   end
 end

data/lib/renderers/html/effect.rb

@@ -28,7 +28,6 @@ new({ renderer: :html, method: :blur, type: :integer }) do |params, _user_proc|
     end
   end
 
-
 new({ renderer: :html, method: :blur, type: :integer, specific: :shadow }) do |params, _user_proc|
   if params[:affect] == :back
     html.backdropFilter(:blur, "#{params[:value]}px")
@@ -39,13 +38,3 @@ new({ renderer: :html, method: :blur, type: :integer, specific: :shadow }) do |p
    affect(affect)
 end
 
-# new({ particle: :blur, category: :effect, type: :int , specific: :shadow}) do |params|
-#   alert :cool
-#   if affect.nil?
-#     affect_to = affect
-#   else
-#     affect_to = [:self]
-#   end
-#   val= { value: params, affect: affect_to } unless params.instance_of?(Hash)
-#   val
-# end

data/lib/renderers/html/event.rb

@@ -1,13 +1,6 @@
 # frozen_string_literal: true
 
 new({ method: :drag, type: :symbol, renderer: :html }) do |params|
-  # if @drag
-  #   option = @drag[params]
-  # else
-  #   params = :remove
-  #   option = true
-  # end
-  # html.event(:drag, params, option)
 
   if params
     option = @drag[params]