atome 0.5.7.1.4 → 0.5.7.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f381b9c8d4123904b8ee97d71b0c6e1f78dc8143eb34b953670a273bd29fad10
-  data.tar.gz: d517e9cf6a13592fda0352bd5aa55c64ff30ffd4a0daab3776ce420c3ec0b970
+  metadata.gz: 49d9ecf130f643cc65b60e7a935dd513871f3ecf0afca6b97476b57650ac0fee
+  data.tar.gz: 60843a34a863fc4ed3b324d0ae29913c58355eb69c7a8a732eb9445c933d256e
 SHA512:
-  metadata.gz: bd812f2209652f5f4e8b24a7d16214cedfc1e8ae5be2149d7f106393cef7f810908f61fbeb33a7854f0bbaab607e63b7d5c46c72c908e27a9cf799e27dd5380e
-  data.tar.gz: 77b884af5e674424861d278dcbd803f094d37600d2bf990cfbd14f041c9103e5cfbd392b772b2065485a5e54b2e146741f7f1654ae96272087d9ab9528eaeff5
+  metadata.gz: e599f47ecf7ab87cf472fe12d95ac2991ad3e192b85e74252304b738537ec0c513bbda6371331912ffaee9fa33be66795a2ba31ca3607296d4e910bd4b06d0b9
+  data.tar.gz: 5041dfd0b3600ec8b406f7a3d9bfbdc6e9e66c3e8b002ba576292d01e6277f379040d1f0f945922a21e33bcc09e8037f8889fb62caf4cb06472bad0109bba827

data/atome.gemspec

@@ -52,7 +52,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
 
-  spec.add_runtime_dependency 'artoo', '~> 1.8.2'
+  # spec.add_runtime_dependency 'artoo', '~> 1.8.2'
   # spec.add_runtime_dependency 'arduino_firmata', '~> 0.3'
   # spec.add_runtime_dependency 'eVe', '~>  0.1.0'
   spec.add_runtime_dependency 'eventmachine', '~> 1.2.7'
@@ -90,7 +90,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency  'wdm', '>= 0.1.0' if Gem.win_platform?
 
   # patch because guard have bad dependency
-  # spec.add_runtime_dependency  'pry', '>= 0.14.2'
+  spec.add_runtime_dependency  'pry', '>= 0.14.2'
 
   # Uncomment to register a new dependency of your gem
   # spec.add_dependency "example-gem", "~> 1.0"

data/lib/atome/extensions/atome.rb

@@ -642,7 +642,53 @@ class Object
     end
   end
 
+  def above(item, margin=6)
+    pos = item.to_px(:bottom) + item.height + margin
+    if item.display == :none
+      33
+    else
+      pos
+    end
+  end
+
+  def below(item, margin=6)
+    pos = item.to_px(:top) + item.to_px(:height) + margin
+    if item.display == :none
+      0
+    else
+      pos
+    end
+
+  end
+
+  def after(item, margin=6)
+    left_f = if item.left.instance_of?(Integer)
+               item.left
+             else
+               item.to_px(:left)
+             end
 
+    width_f = if item.width.instance_of?(Integer)
+                item.width
+              else
+                item.to_px(:width)
+              end
+    pos = left_f + width_f + margin
+    if item.display == :none
+      0
+    else
+      pos
+    end
+  end
+
+  def before(item, margin=6)
+    pos = item.to_px(:right) + item.width + margin
+    if item.display == :none
+      0
+    else
+      pos
+    end
+  end
 
 
 end
@@ -687,6 +733,8 @@ class CssProxy
     bloc.call(parsed)
   end
 
+
+
 end
 
 

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

@@ -334,11 +334,33 @@ new({ particle: :overflow, category: :event, type: :boolean }) do |params, bloc|
   params
 
 end
-new({ particle: :animate, category: :event, type: :hash }) do |params|
+
+class Atome
+  def animation_callback(proc_sub_category, value=nil)
+    # puts  "#{p◊roc_sub_category}"
+    proc_found = @animate_code[proc_sub_category]
+    # puts proc_found
+    instance_exec(value,&proc_found) if proc_found.is_a?(Proc)
+  end
+end
+
+new({ particle: :animate, category: :event, type: :hash }) do |params, proc|
   if params.instance_of? Hash
     params = { from: 0, to: 300, duration: 1000 }.merge(params)
   else
     params = { from: 0, to: 300, duration: 1000 }
   end
-  html.play_animation(params)
+  # @animate_code["#{params[:particle]}"] = proc
+  if params[:end]
+    @animate_code["#{params[:end]}_end"] = proc
+  else
+    @animate_code||= {}
+    @animate_code["#{params[:particle]}"] = proc
+  end
+
+  params
+end
+
+new ({ after: :animate }) do |params|
+  html.animate(params) unless params[:end] || params[:start]
 end

data/lib/atome/genesis/sparkle.rb

@@ -64,6 +64,7 @@ Atome.new(
 Atome.new(
   { renderers: default_render, aid: :view,type: :shape, attach: :user_view, apply: [:view_color],
     tag: { system: true }, left: 0, right: 0, top: 0, bottom: 0, width: :auto, height: :auto, overflow: :auto,
+    language: :english
   }
 
 )
@@ -166,17 +167,18 @@ def init_database
 
   particles = Universe.particle_list
   # now we populate the DB
-  A.sync({ action: :crate_db_table, data: { table: :user, type: :string } }) do |_db_state|
+  A.sync({ action: :create_db_table, data: { table: :user, type: :string } }) do |_db_state|
     # puts "===> #{_db_state}"
   end
-
-  A.sync({ action: :create_db_column, data: { table: :user, column: :email, type: :string, unique: true } }) do |_db_state|
+  A.sync({ action: :create_db_table, data: { table: :atome } }) do |_db_state|
   end
 
-  A.sync({ action: :create_db_column, data: { table: :user, column: :password, type: :string } }) do |_db_state|
+  A.sync({ action: :create_db_table, data: { table: :history } }) do |_db_state|
   end
 
-  A.sync({ action: :crate_db_table, data: { table: :history } }) do |_db_state|
+  A.sync({ action: :create_db_column, data: { table: :user, column: :email, type: :string, unique: true } }) do |_db_state|
+  end
+  A.sync({ action: :create_db_column, data: { table: :user, column: :password, type: :string } }) do |_db_state|
   end
   A.sync({ action: :create_db_column, data: { table: :history, column: :aid, type: :string } }) do |_db_state|
   end
@@ -187,13 +189,6 @@ def init_database
   A.sync({ action: :create_db_column, data: { table: :history, column: :date, type: :datetime } }) do |_db_state|
   end
 
-  A.sync({ action: :crate_db_table, data: { table: :atome } }) do |_db_state|
-  end
-  particles.each do |particle, infos|
-    type = infos[:type]
-    A.sync({ action: :create_db_column, data: { table: :atome, column: particle, type: type } }) do |_db_state|
-    end
-  end
 
   # now we send localstorage content to the server
   puts "sending localstorage"

data/lib/atome/utilities/utilities.rb

@@ -350,18 +350,8 @@ class Atome
 
   def js_callback(id, particle, value, sub = nil)
     current_atome = grab(id)
-    #  # alert current_atome.instance_variable_get('@record_code')
     proc_found = current_atome.instance_variable_get("@#{particle}_code")[particle.to_sym]
-    # proc_found= current_atome.instance_variable_get("@record_code")[:record]
-    #  # alert particle.class
-    #  # alert proc_found.class
-    # proc_found.call
     instance_exec(value, &proc_found) if proc_found.is_a?(Proc)
-    # #  # puts "params to be exec #{id}, #{particle}, #{value}, #{sub}"
-    #  alpha= grab(:the_big_box)
-    #  proc_found= alpha.instance_variable_get("@record_code")[:record]
-    # proc_found.call
-
   end
 
   # def callback(data)

data/lib/atome/version.rb

@@ -2,5 +2,5 @@
 
 #  return atome version
 class Atome
-  VERSION = '0.5.7.1.4'
+  VERSION = '0.5.7.1.7'
 end

data/lib/atome.rb

@@ -37,4 +37,5 @@ require 'atome/utilities/sanitizer'
 require 'atome/genesis/presets'
 require 'atome/genesis/sparkle'
 require 'molecules/init'
-require 'molecules/intuition/utillities'
+require 'molecules/intuition/utilities'
+require 'molecules/intuition/tools'

data/lib/atome_relative.rb

@@ -36,4 +36,5 @@ require_relative './atome/utilities/sanitizer'
 require_relative './atome/genesis/presets'
 require_relative './atome/genesis/sparkle'
 require_relative './molecules/init'
-require_relative './molecules/intuition/utillities'
+require_relative './molecules/intuition/utilities'
+require_relative './molecules/intuition/tools'

data/lib/molecules/intuition/tools.rb

@@ -0,0 +1,359 @@
+# frozen_string_literal: true
+
+size = 33
+smooth = 3
+shadow({
+         id: :tool_shade,
+         left: 3, top: 3, blur: 3,
+         invert: false,
+         red: 0, green: 0, blue: 0, alpha: 0.6
+       })
+
+color({ id: :tool_inactive_color, red: 1, green: 1, blue: 1, alpha: 0.12 })
+color({ id: :tool_active_color, red: 1, green: 1, blue: 1, alpha: 0.3 })
+border({ id: :tool_box_border, thickness: 1, red: 1, green: 1, blue: 1, alpha: 0.06, pattern: :solid, inside: true })
+# Tool's style object container below
+element({ aid: :toolbox_style, id: :toolbox_style, data: {
+  color: :gray,
+  size: size,
+  smooth: smooth
+} })
+
+class Atome
+  class << self
+    def init_intuition
+      Atome.start_click_analysis
+      toolbox_root = Universe.tools_root
+      toolbox_root[:tools].each_with_index do |root_tool, index|
+        tools_scheme = Universe.tools[root_tool]
+        A.build_tool({ name: root_tool, scheme: tools_scheme, index: index ,toolbox: toolbox_root[:toolbox] })
+      end
+    end
+
+    def selection
+      grab(Universe.current_user).selection.collect
+    end
+
+    def activate_click_analysis
+
+      # the condition below avoid touchdown analysis accumulation
+      unless @click_analysis_active
+        # this method analyse all object under the touchdown to find the first user objet and return it's id
+        @click_analysis = lambda { |native_event|
+          # the instance variable below check if we can apply tool (cf:  if the atome we don't want to apply tool)
+          if Universe.allow_tool_operations
+            event = Native(native_event)
+            x = event[:clientX]
+            y = event[:clientY]
+            elements = JS.global[:document].elementsFromPoint(x, y)
+            elements.to_a.each do |atome_touched|
+              id_found = atome_touched[:id].to_s
+              atome_found = grab(id_found)
+              unless atome_found && atome_found.tag[:system]
+
+                # if atome_found
+                Universe.active_tools.each do |tool|
+                  apply_tool(tool, atome_found, event)
+                end
+                break
+              end
+            end
+          else
+            Universe.allow_tool_operations = true
+          end
+        }
+        @click_analysis_active = true
+      end
+
+    end
+
+    def de_activate_click_analysis
+      @click_analysis = nil
+      @click_analysis_active = false
+    end
+
+    def start_click_analysis
+      @click_analysis_active = false
+      JS.global[:document].addEventListener('mouseup') do |native_event|
+        Atome.instance_exec(native_event, &@click_analysis) if @click_analysis.is_a?(Proc)
+      end
+    end
+
+    def alteration(current_tool, tool_actions, atome_touched, a_event)
+      if atome_touched
+        storage_allowed = Universe.allow_localstorage
+        action_found = tool_actions[:action]
+        pre = tool_actions[:pre]
+        post = tool_actions[:post]
+        params = { current_tool: current_tool, atome_touched: atome_touched, event: a_event }
+        action_found.each do |part, val|
+          Universe.allow_localstorage = false
+          #################################
+          touch_found = atome_touched.touch
+          touch_procs = atome_touched.instance_variable_get("@touch_code")
+          resize_found = atome_touched.resize
+          resize_procs = atome_touched.instance_variable_get("@resize_code")
+          current_tool.data[:prev_states][atome_touched] = { events: { touch: touch_found, resize: resize_found },
+                                                             procs: { touch_code: touch_procs, resize_code: resize_procs } }
+          #################################
+          current_tool.instance_exec(params, &pre) if pre.is_a? Proc
+          Universe.allow_localstorage = storage_allowed
+          if current_tool.data[:allow_alteration]
+            atome_touched.send(part, val)
+            current_tool.data[:treated] << atome_touched
+          end
+          current_tool.instance_exec(params, &post) if post.is_a? Proc
+        end
+
+      end
+    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()
+      storage_allowed = Universe.allow_localstorage
+      Universe.allow_localstorage = false
+
+      action_found = tool_actions[:action]
+      pre = tool_actions[:pre]
+      post = tool_actions[:post]
+      params = { current_tool: current_tool, atome_touched: atome_touched, event: a_event }
+
+      action_found.each do |atome, particle|
+        current_tool.instance_exec(params, &pre) if pre.is_a? Proc
+        temp_val = particle.merge({ resize: true, drag: true, top: a_event[:pageY].to_i, left: a_event[:pageX].to_i })
+        if current_tool.data[:allow_creation]
+          # uncomment the line below if you want to attach to current atome
+          if atome_touched
+            new_atome = atome_touched.send(atome, temp_val)
+          else
+            new_atome = 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]
+          Universe.allow_localstorage = [atome]
+          Universe.historicize(new_atome.aid, :write, atome, particle)
+        end
+
+      end
+      current_tool.instance_exec(params, &post) if post.is_a? Proc
+      # we restore prev_local_storage to allow logs of drag and resize ...
+      Universe.allow_localstorage = storage_allowed
+    end
+
+    def apply_tool(tool, atome_touched, a_event)
+      current_tool = grab(tool)
+      tool_actions = current_tool.data
+      method_found = tool_actions[:method]
+      unless method_found
+        method_found = :alteration
+        tool_actions[:action] = { noop: true }
+        current_tool.data = tool_actions
+      end
+
+      send(method_found, current_tool, tool_actions, atome_touched, a_event)
+    end
+
+  end
+
+  def noop(_p)
+    # this method is used by tools when no treatment is needed
+  end
+
+  def set_action_on_touch(&action)
+    @touch_action = action
+
+  end
+
+  def remove_get_atome_on_touch
+    @touch_action = nil
+  end
+
+  def build_tool(params)
+    # here is the main entry for tool creation
+    language ||= grab(:view).language
+
+    label = params.dig(:scheme, :int8, language) || params[:name]
+    tool_name = "#{params[:name]}_tool"
+    index = params[:index]
+    tool_scheme = params[:scheme]
+    toolbox=params[:toolbox] || {}
+    orientation_wanted = tool_scheme[:orientation] || :sn
+    color({ id: :active_tool_col, alpha: 1, red: 1, green: 1, blue: 1 })
+    color({ id: :inactive_tool_col, alpha: 0.6 })
+    grab(:intuition).storage[:tool_open] ||= []
+    grab(:intuition).storage[:tool_open] << tool_name
+    size = grab(:toolbox_style).data[:size]
+    smooth = grab(:toolbox_style).data[:smooth]
+    case orientation_wanted
+    when :sn
+      top = :auto
+      bottom_offset=toolbox[:bottom] || 3
+      spacing = toolbox[:spacing] || 3
+      bottom = index * (size + spacing)+bottom_offset
+      left = toolbox[:left] || 3
+      right = :auto
+    when :ns
+    when :ew
+    when :we
+    else
+      #
+    end
+
+    # tool creation
+    if tool_scheme[:creation]
+      action = tool_scheme[:creation]
+      method = :creation
+    end
+    if tool_scheme[:alteration]
+      action = tool_scheme[:alteration]
+      method = :alteration
+    end
+
+    tool = grab(:intuition).box({ id: tool_name,
+                                  tag: { system: true },
+                                  # orientation: orientation_wanted,
+                                  top: top,
+                                  bottom: bottom,
+                                  left: left,
+                                  right: right,
+                                  width: size,
+                                  height: size,
+                                  smooth: smooth,
+                                  apply: [:tool_inactive_color, :tool_box_border, :tool_shade],
+                                  state: :closed,
+                                  data: { method: method,
+                                          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],
+                                  }
+
+                                })
+    edition = "M257.7 752c2 0 4-0.2 6-0.5L431.9 722c2-0.4 3.9-1.3 5.3-2.8l423.9-423.9c3.9-3.9 3.9-10.2 0-14.1L694.9 114.9c-1.9-1.9-4.4-2.9-7.1-2.9s-5.2 1-7.1 2.9L256.8 538.8c-1.5 1.5-2.4 3.3-2.8 5.3l-29.5 168.2c-1.9 11.1 1.5 21.9 9.4 29.8 6.6 6.4 14.9 9.9 23.8 9.9z m67.4-174.4L687.8 215l73.3 73.3-362.7 362.6-88.9 15.7 15.6-89zM880 836H144c-17.7 0-32 14.3-32 32v36c0 4.4 3.6 8 8 8h784c4.4 0 8-3.6 8-8v-36c0-17.7-14.3-32-32-32z"
+
+    icon= tool.vector({ tag: { system: true }, left: 9, top: :auto, bottom: 9, width: 18, height: 18, id: "#{tool_name}_icon",
+                  data: { path: { d: edition, id: :p1, stroke: :black, 'stroke-width' => 37, fill: :white } }})
+    # wait 2 do
+    # alert "#{tool_name}_icon"
+    # alert "current vector : #{grab("#{tool_name}_icon").id}"
+    grab("#{tool_name}_icon").color(:blue)
+    # icon.color(:red)
+    # end
+    # icon= tool_scheme[:icon] || params[:name]
+    # tool.image({path: "medias/images/icons/#{icon}.svg"})
+    tool.text({ tag: { system: true }, data: label, component: { size: 9 }, color: :grey, id: "#{tool_name}_label" })
+    code_for_zone = tool_scheme[:zone]
+    tool.instance_exec(tool, &code_for_zone) if code_for_zone.is_a? Proc
+    tool.touch(true) do
+      # we add all specific tool actions to @tools_actions_to_exec hash
+      # we set allow_tool_operations to false to ignore tool operation when clicking on a tool
+      Universe.allow_tool_operations = false
+      # we create the creation_layer if not already exist
+      tick(tool_name)
+      # active code exec
+      if tick[tool_name] == 1 # first click
+        events_allow = [:top, :left, :right, :bottom, :width, :height]
+        alterations = tool_scheme[:alteration] ? tool_scheme[:alteration].keys : []
+        creations = tool_scheme[:creation] ? tool_scheme[:creation].keys : []
+        prev_auth = Universe.allow_localstorage ||= []
+        storage_allowed = events_allow.concat(alterations).concat(creations).concat(prev_auth).uniq
+        Universe.allow_localstorage = storage_allowed
+        # we set edit mode to true (this allow to prevent user atome to respond from click)
+        Universe.edit_mode = true
+        Universe.active_tools << tool_name
+        # init the tool
+        tool.data[:treated] = []
+        tool.data[:created] = []
+        tool.data[:prev_states] = {}
+        # generic behavior
+        tool.apply(:active_tool_col)
+        # activation code
+        activation_code = tool_scheme[:activation]
+        tool.instance_exec(&activation_code) if activation_code.is_a? Proc
+        # below we the particles of selected atomes to feed tools values
+        # possibility 1 (pipette like):
+        # now we get the values from selected atomes
+        Atome.selection.each do |atome_id_to_treat|
+          tool.data[:action].each do |particle_req, value_f|
+            unless Universe.atome_preset
+              value_found = grab(atome_id_to_treat).send(particle_req)
+              if value_found
+                tool.data[:action][particle_req] = value_found
+              else
+              end
+            end
+          end
+        end
+        # possibility 2  (immediate apply):
+        allow_creation = tool.data[:allow_creation]
+        allow_alteration = tool.data[:allow_alteration]
+        Atome.selection.each do |atome_id_to_treat|
+          atome_found = grab(atome_id_to_treat)
+          event = { pageX: 0, pageY: 0, clientX: 0, clientY: 0 }
+          Atome.apply_tool(tool_name, atome_found, event)
+        end unless tool_name.to_sym == :select_tool || !allow_creation || !allow_alteration
+
+        # activate tool analysis test
+        Atome.activate_click_analysis
+      else
+        Universe.allow_localstorage = false
+        # when closing delete tools action from tool_actions_to_exec
+        Universe.active_tools.delete(tool_name)
+        # we check if all tools are inactive if so we set edit_mode to false
+        if Universe.active_tools.length == 0
+          Atome.de_activate_click_analysis
+          Universe.edit_mode = false
+        end
+
+        inactivation_code = tool_scheme[:inactivation]
+        tool.instance_exec(tool.data, &inactivation_code) if inactivation_code.is_a? Proc
+        # end if tool_content && tool_content[:inactive]
+
+        # generic behavior
+        # we remove touch and resize binding on newly created atomes
+        tool.apply(:inactive_tool_col)
+        tool.data[:created].each do |new_atome|
+          new_atome.drag(false)
+          new_atome.resize(:remove)
+        end
+        ################################
+        # we restore prev touch and resize
+        tool.data[:prev_states].each do |atome_f, prev_par|
+          puts prev_par
+          # params[:events].each do |part_f, val_f|
+          #   # alert "@#{part_f}, #{part_f}"
+          #   atome_f.send(part_f, val_f)
+          # end
+          # alert "--> params :  #{params[:events]}"
+          # alert "--> procs :  #{params[:procs][params[:events]]}"
+          # atome_f.touch(false)
+          # atome_f.touch(true) do
+          #   alert :kool
+          # end
+          # alert params[:procs]
+          # params[:procs].each do |var_n, procs_f|
+          #   # procs_f.each do |action_f, proc|
+          #   #   # puts "#{var_n}==> #{action_f}, #{proc}"
+          #   # end
+          #   puts "==> #{var_n}, #{proc_f}"
+          #   # atome_f.instance_variable_set("@#{var_n}", proc_f)
+          # end
+          # atome_f.touch(false)
+          # alert "#{atome_f.touch} : #{atome_f.instance_variable_get("@touch_code")}"
+        end
+
+        # atome_f.touch(touch_found)
+        # atome_f.resize(resize_found)
+        # inactivation code
+        #################################
+        tick[tool_name] = 0
+      end
+    end
+  end
+end

data/lib/molecules/intuition/{utillities.rb → utilities.rb}

@@ -129,7 +129,6 @@ new(molecule: :list) do |params, _bloc|
     # let's create the container
     new_atome = { renderers: renderer_found, attach: list.id }.merge(styles_found).merge({ type: :shape })
 
-
     el = Atome.new(new_atome)
     if action
       el.touch(action[:touch]) do
@@ -329,11 +328,11 @@ class Atome
 
     width(params[:width])
     height(params[:height])
-    current_matrix=self
+    current_matrix = self
     real_width = current_matrix.to_px(:width)
     real_height = current_matrix.to_px(:height)
     spacing = current_matrix.data[:spacing]
-    matrix_cells= current_matrix.data[:matrix]
+    matrix_cells = current_matrix.data[:matrix]
 
     total_spacing_x = spacing * (matrix_cells.collect.length ** (0.5) + 1)
     total_spacing_y = spacing * (matrix_cells.collect.length ** (0.5) + 1)
@@ -363,13 +362,21 @@ class Atome
 end
 
 new(molecule: :matrix) do |params, &bloc|
-  id = params[:id]
-  rows = params[:rows]
-  columns = params[:columns]
-  spacing = params[:spacing]
-  size = params[:size]
+  params  ||= {}
+  # We test if self is main if so we attach the matrix to the view
+  parent_found = if self == self
+                   grab(:view)
+                 else
+                   self
+                 end
+
+  id = params[:id] || identity_generator
+  rows = params[:rows] || 8
+  columns = params[:columns] || 8
+  spacing = params[:spacing] || 6
+  size = params[:size] || '100%'
 
-  parent_found = self
+  # parent_found = self
   current_matrix = group({ id: id })
 
   current_matrix.data({ spacing: spacing, size: size })
@@ -414,7 +421,7 @@ new(molecule: :matrix) do |params, &bloc|
   end
   current_matrix.collect(matrix_cells)
   matrix_back.cells(current_matrix)
-  params= params.merge({matrix: current_matrix})
+  params = params.merge({ matrix: current_matrix })
   matrix_back.data(params)
   matrix_back
 end