atome_eVe 0.1.0.0.1 → 0.1.0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec0c847b3b282967f232266434d895585a578afc05b0b0fe8e26f16e1ecc4480
-  data.tar.gz: 4d0138c8af264ccd9215d8716695a22aec2bb1bf8773040cd70b4a4865474af2
+  metadata.gz: b1cf47e4cdc5b85b545e8ac608bd7e60ce503e2d5aa9c3894c695b9cc6761af2
+  data.tar.gz: 24dda873d0003bb4601ee8b0b4b3bded94a9c0343f0cd7aa3e39a0a20c48fbb1
 SHA512:
-  metadata.gz: 66cfb7c567cbc4219da1c542856664a36bc8b597bb7f17a460fc4002db75f5e84051a79d2d71fd067c1f79e2f4c468a94cb3970cea551e3fc7655d0e7afb2230
-  data.tar.gz: c8a097860eb0a2634e511844c5f9987edded062a958875d597a64601c46f441772334e34a1456413629719eacf1c3957a3465145e56c524d0c56a89dfa17883d
+  metadata.gz: 47e38e24db94c2d34ff15be016017ea3fe886ece643db45439f93481e2265152184e1038bc80575940a5f65f5c066ce9089f41add9a2bf160a34b54db330af4d
+  data.tar.gz: 209c0e94d5992260b51cfb81022043f3e4763f05c4b62cbe062854f3ac80baa5514e4970194d3c8e8655942a6fddee57e71b5baedce385426419cdec330b43e4

data/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

data/.idea/atome_eVe.iml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="RUBY_MODULE" version="4">
+  <component name="ModuleRunConfigurationManager">
+    <shared />
+  </component>
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/features" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/spec" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" scope="PROVIDED" name="bundler (v2.5.5, rbenv: 3.3.0) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="minitest (v5.22.2, rbenv: 3.3.0) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rake (v13.1.0, rbenv: 3.3.0) [gem]" level="application" />
+  </component>
+</module>

data/.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="rbenv: 3.3.0" project-jdk-type="RUBY_SDK" />
+</project>

data/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/atome_eVe.iml" filepath="$PROJECT_DIR$/.idea/atome_eVe.iml" />
+    </modules>
+  </component>
+</project>

data/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

data/atome_eVe.gemspec

@@ -4,7 +4,7 @@ require_relative "lib/eVe/version"
 
 Gem::Specification.new do |spec|
   spec.name = "atome_eVe"
-  spec.version = AtomeEVe::VERSION
+  spec.version = EVe::VERSION
   spec.authors = ["Jean-Eric Godard"]
   spec.email = ['jeezs@atome.one']
 
@@ -13,7 +13,7 @@ Gem::Specification.new do |spec|
   spec.homepage = 'https://atome.one'
   spec.license = 'MIT'
   spec.required_ruby_version = '>= 3.1'
-  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  # Warning do not remove or change the line below eVe must not be push on Rubygems server
   # spec.metadata['allowed_push_host'] = 'http://local.only'
 
   spec.metadata['homepage_uri'] = spec.homepage

data/lib/eVe/examples/site.rb

@@ -0,0 +1,34 @@
+
+new(application: {name: :compose })
+
+
+grab(:toto).color(:cyan)
+
+def layout
+  compose_back=box
+
+  compose_back.color({ alpha: 0 })
+  media_reader=compose_back.box({left: 99, width: 250, height: 250, top: 99})
+  viewer_1=compose_back.box({left: 360, width: 250, height: 250, top: 99})
+  viewer_2=compose_back.box({left: 690, width: 250, height: 250, top: 99})
+  timeline=compose_back.box({left: 99, width: 250, height: 250, top: 399})
+  login=compose_back.text(:log)
+  login.touch(true) do
+    compose_back.delete(true)
+    # grab(:view).clear(true)
+    form
+  end
+
+end
+
+def form
+  form1=box
+  form1.text(:login)
+
+  form1.touch(true) do
+    form1.delete(true)
+    layout
+  end
+
+end
+form

data/lib/eVe/init.rb

@@ -1 +1,54 @@
 # frozen_string_literal: true
+
+Universe.eVe(true)
+puts "eVe version : #{EVe::VERSION}"
+
+module EVe
+  def new(params, &bloc)
+    if params[:page]
+      site_found = grab(params[:page][:application])
+      site_found.clear(true)
+      page_id = params[:page][:name]
+      site_found.box({ id: page_id })
+    elsif params[:application]
+
+      footer_header_size=33
+      footer_header_color=color({red: 0, green: 0, blue: 0, id: :footer_header_color})
+
+      if params[:header]
+        top = footer_header_size
+        header=box({ left: 0, right: 0, width: :auto, top: 0, height: top, id: :header })
+        # header.attach(:footer_header_color)
+      else
+        top = 0
+        end
+        if params[:footer]
+          bottom = footer_header_size
+          box({ left: 0, right: 0, width: :auto, top: :auto, bottom: 0, height: bottom, id: :footer })
+        else
+          bottom = 0
+        end
+        box({ left: 0, right: 0, width: :auto, top: top, bottom: bottom, height: :auto, id: params[:application] })
+        elsif params[:module]
+
+      end
+      super if defined?(super)
+    end
+  end
+
+  class Object
+    include EVe
+  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/eVe/intuition/inputs.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+# def atome_common(atome_preset, params)
+#   basic_params = { renderers: [] }
+#   # 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] || {}
+#
+#   basic_params[:type] = preset_params[:type] || :element
+#   basic_params[:id] = params[:id] || identity_generator(atome_preset)
+#   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)
+#
+#   # condition to handle color/shadow/paint atomes that shouldn't be attach to view
+#   # TODO : add category for atome( material/physical vs modifier : color, shadow, .. vs shape, image ..)
+#   # then add condition same things fo code in genesis new_atome
+#   if %i[color shadow paint].include?(atome_preset)
+#     unless params[:affect]
+#       params[:affect] = if @id == :view
+#                           [:black_matter]
+#                         else
+#                           [@id]
+#                         end
+#     end
+#   else
+#     params[:attach] = params[:attach] || @id || :view
+#   end
+#   params
+# end
+#
+# def preset_common(params, &bloc)
+#   # if an atome with current id exist we update the ID in the params
+#   params[:id] = "#{params[:id]}_#{Universe.atomes.length}" if grab(params[:id])
+#   Atome.new(params, &bloc)
+# end
+# class EVe < Atome
+class EVe < Atome
+  def initialize
+    @atomes = {}
+  end
+
+  def atome(atome_to_find)
+    @atomes[atome_to_find]
+  end
+
+  def input_box(params = {}, &bloc)
+    height_wanted = 15
+    width_wanted = 222
+    input_back = Atome.new(
+      { renderers: [:html], id: :input_back, type: :shape, attach: :view, apply: [:shape_color],
+        left: 120, top: 120,data: '', width: width_wanted, height: height_wanted + height_wanted * 20 / 100, smooth: 6 })
+
+    @atomes[:input_back] = input_back
+
+    Atome.new(
+      { renderers: [:html], id: :input_text_color, type: :color, tag: ({ system: true, persistent: true }),
+        red: 0.1, green: 0.1, blue: 0.1, alpha: 1 }
+    )
+
+    text_input = Atome.new(
+      { renderers: [:html], id: :input_text, type: :text, apply: [:input_text_color], component: { size: height_wanted },
+        data: :input, left: height_wanted * 20 / 100, top: 0, edit: true, attach: :input_back, height: height_wanted, position: :absolute })
+
+    text_input.touch(true) do
+      text_input.component({ selected: { color: 'rgba(0,0,0,0.3)', text: :orange } })
+    end
+
+    text_input.keyboard(:down) do |native_event|
+      event = Native(native_event)
+      if event[:keyCode].to_s == '13'
+        # we prevent the input
+        event.preventDefault()
+      end
+
+    end
+
+    text_input.keyboard(:up) do |native_event|
+      input_back.data=text_input.data
+    end
+    @atomes[:input_text] = text_input
+
+    input_back
+  end
+
+end
+
+def input(params = {}, &proc)
+  text_color = :white
+  text_size = 12
+  back_color = :gray
+  width = 2000
+  in_b = EVe.new()
+  in_b.input_box
+end
+
+i= input
+
+b=box({top: 0, left: 0, width: 33, height: 33})
+b.touch(true) do
+  puts "i.data : #{i.data}"
+end
+i.left(66)
+i.color(:white)
+i.text.left(55)
+
+
+
+
+

data/lib/eVe/intuition/sliders.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+button = box({smooth: 6,left: 55,top: 160, color:{red: 0.3, green: 0.3, blue: 0.3},id: :my_box})
+button.shadow({
+                id: :s1,
+                left: 3, top: 3, blur: 9,
+                invert: true,
+                red: 0, green: 0, blue: 0, alpha: 0.7
+              })
+button.touch(true) do
+  button.controller(:hello)
+end
+slider=box({ width: 333, height: 25, top: 45, left: 55, smooth: 9,  color:{red: 0.3, green: 0.3, blue: 0.3}})
+slider.shadow({
+                id: :s2,
+                left: 3, top: 3, blur: 9,
+                invert: true,
+                red: 0, green: 0, blue: 0, alpha: 0.7
+              })
+cursor= slider.circle({width: 30, height: 30, left: 2, top: 1, color:{red: 0.3, green: 0.3, blue: 0.3}})
+
+cursor.left(0)
+cursor.top(0)
+cursor.shadow({
+                id: :s4,
+                left: 1, top: 1, blur: 3,
+                option: :natural,
+                red: 0, green: 0, blue: 0, alpha: 0.6
+              })
+label=text({data: 0, top: 69, left: 69, component: { size: 12 }, color: :gray})
+cursor.drag({ restrict: {max:{ left: 309, top: 0}} }) do |event|
+  puts cursor.left
+  value = cursor.left/309*100
+  label.data(value)
+  cursor.controller({ action: :setModuleParameterValue,  params: { moduleId: 6456549897,parameterId: 9846546, value:  value} })
+
+end
+support=box({top: 300, left: 55, width: 300, height: 40, smooth: 9, color:{red: 0.3, green: 0.3, blue: 0.3}, id: :support })
+support.shadow({
+                 id: :s3,
+                 left: 3, top: 3, blur: 9,
+                 invert: true,
+                 red: 0, green: 0, blue: 0, alpha: 0.7
+               })
+support.import(true) do  |content|
+  puts "add code here, content:  #{content}"
+end
+
+in_box=input_box

data/lib/eVe/intuition/toolbox.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+text(:hello)
+class Atome
+
+  def build_tool(&bloc)
+    # alert params[:tool]
+    a = Atome.instance_exec(&bloc)
+    puts "===> a is : #{a[:action]}"
+    # check below
+    wait 2 do
+      send a[:action]
+    end
+    grab(:toolbox).box({color: :white, width: 33, height: 33})
+  end
+end
+
+class Object
+  def new(params, &bloc)
+    # Genesis = Genesis.Genesis
+    if params.key?(:atome)
+      Universe.add_atomes_specificities params[:atome]
+      Genesis.build_atome(params[:atome], &bloc)
+    elsif params.key?(:particle)
+      Atome.instance_variable_set("@main_#{params[:particle]}", bloc)
+      # 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
+      Genesis.build_particle(params[:particle], { render: params[:render], return: params[:return],
+                                                  store: params[:store], type: params[:type] }, &bloc)
+    elsif params.key?(:sanitizer)
+      Genesis.build_sanitizer(params[:sanitizer], &bloc)
+    elsif params.key?(:pre)
+      Atome.instance_variable_set("@pre_#{params[:pre]}", bloc)
+    elsif params.key?(:post)
+      Atome.instance_variable_set("@post_#{params[:post]}", bloc)
+    elsif params.key?(:after)
+      Atome.instance_variable_set("@after_#{params[:after]}", bloc)
+    elsif params.key?(:read)
+      Atome.instance_variable_set("@read_#{params[:read]}", bloc)
+    elsif params[:renderer]
+      renderer_found = params[:renderer]
+      if params[:specific]
+        Universe.set_atomes_specificities(params)
+        params[:specific] = "#{params[:specific]}_"
+      end
+      render_method = "#{renderer_found}_#{params[:specific]}#{params[:method]}"
+      Genesis.build_render(render_method, &bloc)
+    elsif params.key?(:callback)
+      particle_targetted = params[:callback]
+      Atome.define_method "#{particle_targetted}_callback" do
+        bloc.call
+      end
+    elsif params.key?(:tool)
+      A.build_tool(&bloc)
+    end
+  end
+end
+
+grab(:intuition).box({id: :toolbox, top: :auto, bottom: 0, left: 0, width: 50, height: 255})
+
+def record_tool
+  grab(Universe.current_user).selection
+  alert "must get selection to treat it "
+end
+
+
+module Intuition
+  def intuition_int8
+    # tool taxonomy and list
+    {
+      capture: { int8: { french: :enregistrement, english: :record, german: :datensatz } },
+      communication: { french: :communication, english: :communication, german: :communication },
+      tool: { french: :outils, english: :tools, german: :werkzeuge },
+      view: { french: :vue, english: :view, german: :aussicht },
+      time: { french: :horloge, english: :clock, german: :Uhr },
+      find: { french: :trouve, english: :find, german: :finden },
+      home: { french: :accueil, english: :home, german: :zuhause },
+      code: { french: :code, english: :code, german: :code },
+      impulse: { french: :impulse, english: :impulse, german: :impulse },
+    }
+  end
+  def intuition_taxonomy
+
+  end
+
+  def impulse
+    # tool start point
+    [:capture, :communication, :tool, :view, :time, :find, :home]
+  end
+
+  # def capture
+  #   categories=ATOME.methods_categories
+  #   [categories[:inputs]]
+  # end
+  #
+  # def communication
+  #   categories=ATOME.methods_categories
+  #   [categories[:communications]]
+  # end
+  #
+  # def toolz
+  #   categories=ATOME.methods_categories
+  #   [categories[:spatials],categories[:helpers],categories[:materials],
+  #    categories[:geometries],categories[:effects],
+  #    categories[:medias],categories[:hierarchies],categories[:utilities],categories[:events]]
+  # end
+  #
+  # def tool_style(size = 33)
+  #   # styling
+  #   shadows = [{ x: size / 15, y: size / 15, thickness: 0, blur: size / 3, color: { red: 0, green: 0, blue: 0, alpha: 0.3 } }, { x: -size / 15, y: -size / 15, thickness: 0, blur: size / 6, color: { red: 1, green: 1, blue: 1, alpha: 0.3 } }]
+  #   style = { type: :tool, content: { points: 4 }, color: { red: 0.9, green: 0.9, blue: 0.9, alpha: 0.15 }, parent: :intuition, shadow: shadows, blur: { value: 6, invert: true } }
+  #   return style
+  # end
+  #
+  # def open_tool(tool_id, widthness=3, orientation=:x, speed=0.6)
+  #   if orientation == :x
+  #     orientation = :width
+  #     value = grab(tool_id).width
+  #   else
+  #     orientation = :height
+  #     value = grab(tool_id).height
+  #   end
+  #   animate({
+  #             start: { orientation => value },
+  #             end: { orientation => value * widthness },
+  #             duration: speed * 1000,
+  #             loop: 0,
+  #             curve: :easing,
+  #             target: tool_id
+  #           })
+  #   notification "find why this id #{self.atome_id}, add annimation callback to set overflow when anim complete"
+  #   grab(tool_id).overflow(:visible)
+  # end
+  #
+  # def close_tool(tool_id, widthness, orientation, speed)
+  #   if orientation == :x
+  #     orientation = :width
+  #     value = grab(tool_id).width
+  #   else
+  #     orientation = :height
+  #     value = grab(tool_id).height
+  #   end
+  #   animate({
+  #             start: { orientation => value * widthness },
+  #             end: { orientation => value },
+  #             duration: speed * 1000,
+  #             loop: 0,
+  #             curve: :easing,
+  #             target: tool_id
+  #           })
+  #   # grab(tool_id).overflow(:hidden)
+  # end
+  #
+  # def create_tool(tool_name, size = 33, x_pos = 0, y_pos = 33, offsset=0)
+  #   tool_created = tool(self.tool_style(size).merge({ parent: :main_menu, atome_id: "tool_" + tool_name, id: "tool_" + tool_name,
+  #                                                     width: size, height: size, smooth: size / 9, overflow: :hidden, x: x_pos, y: y_pos, z: 1, content: [] }))
+  #   icon=tool_created.shape({ path: tool_name, width: size - size / 2, height: size - size / 2, center: true })
+  #   # name = intuition_list[tool_name][language]
+  #   particle({ atome_id: :tools_property_container, color: { red: 0.6, green: 0.6, blue: 0.6 } })
+  #   # we get the plugin code only if the plugin hasn't been interpreted before (unless condition below)
+  #   unless grab(:intuition).content.include? tool_name
+  #     ATOME.reader("./medias/e_rubies/tools/#{tool_name}.rb") do |data|
+  #       #  todo add a security parser here
+  #       # we set the variable tool that can be used to facilitate plugin creation
+  #       data="tool=grab(:#{tool_created.atome_id})\n"+data
+  #       compile(data)
+  #       # we add the tool to the intuition content so it won't be loaded twice
+  #       grab(:intuition).content |= [tool_name]
+  #     end
+  #   end
+  #   # end
+  #   tool_created.active({ exec: false })
+  #   tool_created.inactive({ exec: false })
+  #   icon.touch(stop: true) do
+  #     if tool_created.active[:exec] == true
+  #       tool_created.color(:transparent)
+  #       tool_created.active(exec: false, proc: tool_created.active[:proc]  )
+  #       tool_created.inactive(exec: true, proc: tool_created.inactive[:proc]  )
+  #     else
+  #       tool_created.color({alpha: 0.3})
+  #       tool_created.active({ exec: true, proc: tool_created.active[:proc]  })
+  #     end
+  #   end
+  # end
+  #
+  # # we get menu entry point
+  # def open_intuition(position = {})
+  #   position = { x: 0, yy: 0, size: 33, orientation: :vertical, offset: 0 }.merge(position)
+  #   # we get content language from view's language
+  #   if grab(:main_menu)
+  #     grab(:main_menu).delete
+  #   else
+  #     grab(:view).language
+  #     self.language(grab(:view).language)
+  #     orientation = position.delete(:orientation)
+  #     size = position.delete(:size)
+  #     offset = position.delete(:offset)
+  #     # positioning and scaling
+  #     if orientation == :vertical
+  #       requested_width = size
+  #       requested_height = (size+offset)* impulse.length
+  #     else
+  #       requested_width = (size+offset) * impulse.length
+  #       requested_height = size
+  #     end
+  #     tool({ atome_id: :main_menu, parent: :intuition, color: { alpha: 0 } }.merge(position).merge(width: requested_width, height: requested_height))
+  #     impulse.each_with_index do |item, index|
+  #       if orientation == :vertical
+  #         create_tool(item, size, 0, index * (size+offset))
+  #       else
+  #         create_tool(item, size, index * (size+offset), 0)
+  #       end
+  #     end
+  #   end
+  # end
+end
+# atome class extension for eVe
+
+class Atome
+  include Intuition
+  #  def atome(requested_property)
+  #    # add component list iin the content we maybe ahave to create a tool object because box can't handle this type of content
+  #    new_atome=self.tool({ atome_id: "#{self.atome_id}_#{requested_property}_atome_#{self.content.length}", x: 66})
+  #    new_atome.touch({ stop: true, option: :down}) do
+  #      color(:red)
+  #      new_atome.height = new_atome.height*3
+  #    end
+  #    new_atome.touch({ stop: true, option: :up}) do
+  #      color(:red)
+  #      new_atome.height = new_atome.height/3
+  #    end
+  #    notification "now we have to add an object or a new property (style) to store complete tool style including size and
+  # orientation so we can position the new atome correctly"
+  #    # alert self.content.class
+  #    # alert self.content.length
+  #    # alert tool_style
+  #  end
+end
+
+# # we initialise the toolbox here :
+#
+# # the launch bar
+# launch_bar = box({ x: 0, y: 0, width: 33, height: "100%", parent: :intuition, z: 0, color: { alpha: 0 } })
+# launch_bar.touch({ option: :long }) do |evt|
+#   size = 33
+#   yy_touch_position = grab(:view).convert(:height) - evt.page_y
+#   if yy_touch_position < size
+#     #if the long touch is within the wanted area( in this  at bottom of the screen) we open the menu
+#     # launch_bar.open_intuition({ x: size, yy: 6,offset: 6, orientation: :horizontal, size: size })
+#     launch_bar.open_intuition({ x: 6, yy: size,offset: 6, orientation: :vertical, size: size })
+#   end
+# end
+#
+# # # # # # # # # # # # # # # tests below   # # # # # # # # # # # # #
+#
+# list = molecule_analysis(@molecules_list)
+# notif list[:tools]
+# notif "======"
+# notif list[:molecules]
+# notif "======"
+# notif list[:atomes]
+# notif "======"
+# notif list[:molecules][:shadow]
+
+new({ tool: :capture }) do |params|
+  tool = { id: :rec_01,
+
+           name: :record, icon: :record, action: {open: [:sub_menu]},  code: :record_tool, position: { root: 1 }, # position can be multiple
+           option: { opt1: :method_2 }, int8: { french: :enregistrement, english: :record, german: :datensatz } }
+  tool
+end
+
+
+puts A.impulse
+# def fill_toolzone(tools_ids)
+#
+# end
+#
+# fill_toolzone(%i[files edition select group link copy undo settings])
+

data/lib/eVe/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module AtomeEVe
-  VERSION = "0.1.0.0.1"
+module EVe
+  VERSION = "0.1.0.0.6"
 end

data/lib/eVe_relative.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "eVe/version"
+require_relative "eVe/init"
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atome_eVe
 version: !ruby/object:Gem::Version
-  version: 0.1.0.0.1
+  version: 0.1.0.0.6
 platform: ruby
 authors:
 - Jean-Eric Godard
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-23 00:00:00.000000000 Z
+date: 2024-02-24 00:00:00.000000000 Z
 dependencies: []
 description: for atome the creative framework
 email:
@@ -17,21 +17,30 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".idea/.gitignore"
+- ".idea/atome_eVe.iml"
+- ".idea/misc.xml"
+- ".idea/modules.xml"
+- ".idea/vcs.xml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
 - Rakefile
 - atome_eVe.gemspec
-- lib/atome_eVe.rb
+- lib/eVe.rb
+- lib/eVe/examples/site.rb
 - lib/eVe/init.rb
+- lib/eVe/intuition/inputs.rb
+- lib/eVe/intuition/sliders.rb
+- lib/eVe/intuition/toolbox.rb
 - lib/eVe/version.rb
+- lib/eVe_relative.rb
 - sig/atome_eVe.rbs
 homepage: https://atome.one
 licenses:
 - MIT
 metadata:
-  allowed_push_host: https://rubygems.org
   homepage_uri: https://atome.one
   source_code_uri: https://github.com/atomecorp/atome
   changelog_uri: https://github.com/atomecorp/atome/changelog
@@ -50,7 +59,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.5
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: atome companion