atome 0.5.6.0.4 → 0.5.6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b631fc09724548cd4174533e5268f6372b99666faa476dc825bbc4e37ebcd1b3
-  data.tar.gz: 55f81e5c141e9a4bada159e02196ae72d47fa60eac7b4c117b6c1c4dea3bddc9
+  metadata.gz: 66985b0d1acf2097aa11e2a9689259505c7740df5bfab53aece65f8c1ba41d90
+  data.tar.gz: '0012873d2c2b3ffa1ace79916653528bc729930c8d96a56a9fba96dabd36ee66'
 SHA512:
-  metadata.gz: cd78709ac74a5ba36f1b5fb047f42f4610460cf38ca77a368585b832a2fbb478f57d9198cd07a3ddbd82352a8916a6885ff6faf6480c253a220a339c179d106c
-  data.tar.gz: 7b1b793d748434f5a47f8f41843b6ed4e5ef8de0007cffe02ab4a278c5489a89c71e18f8ffa08cce9a8633a890a6970f1f5eb3fc463029801d028b869c3050a1
+  metadata.gz: 7ca3e5e5de3d1967319e113e85262fe6c98293c528e90033f474881776effee50bd89882479984b14595422668fb52af06e612cc87c4d3cc83524709e8bf2994
+  data.tar.gz: a7b97cff089977811808b83bd04bb30349c9184ad5562c54d43c1268bfc1d7aedecf46911460e90e8376eac6b8beb537644f5c1d886d6e14f73f3e50b33c3289

data/Rakefile

@@ -8,6 +8,19 @@ require 'rubygems/uninstaller'
 require 'bundler/gem_tasks'
 load 'exe/atome'
 
+
+
+folder_name = 'lib/eVe'
+
+unless Dir.exist?(folder_name)
+  Dir.mkdir(folder_name)
+    File.open('lib/eVe/eVe_relative.rb', 'w') do |file|
+    end
+    File.open('lib/eVe/eVe.rb', 'w') do |file|
+    end
+end
+
+
 task :cleanup do
 
   manager = Gem::CommandManager.instance
@@ -185,7 +198,7 @@ task :test_server do
   threads = []
   threads << Thread.new do
 
-
+    sleep 1
     if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
       # code to exec for Windows
        `start  http://localhost:9292`

data/atome.gemspec

@@ -22,17 +22,32 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
 
+  # spec.files = Dir.chdir(File.expand_path(__dir__)) do
+  #   `git ls-files -z`.split("\x0").reject do |f|
+  #     (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+  #   end
+  # end
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject do |f|
+    # Utilisez git ls-files pour récupérer les fichiers, puis filtrez-les selon vos besoins
+    git_files = `git ls-files -z`.split("\x0").reject do |f|
       (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
     end
+
+    # Ajoutez manuellement les fichiers du dossier lib/eVe
+    eve_files = Dir['lib/eVe/**/*']
+
+    # Combine les deux listes de fichiers
+    git_files + eve_files
   end
 
   spec.bindir = 'exe'
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+
+  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'
   spec.add_runtime_dependency 'faye-websocket', '~> 0.1'
   spec.add_runtime_dependency 'geocoder', '~> 1.8'
@@ -40,6 +55,7 @@ Gem::Specification.new do |spec|
   # spec.add_runtime_dependency 'guard-shell', '~> 0.7.2'
   # spec.add_runtime_dependency 'guard-puma', '~> 0.8.1'
   # spec.add_runtime_dependency 'shotgun', '~> 0.9.2'
+  spec.add_runtime_dependency 'gems', '~> 1.2'
   spec.add_runtime_dependency 'guard-rake', '~> 1.0'
   # spec.add_runtime_dependency 'rerun', '~> 0.14.0'
   spec.add_runtime_dependency 'image_size', '~> 3.0'
@@ -58,12 +74,11 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'sequel', '~> 5.5'
   spec.add_runtime_dependency 'sqlite3', '~> 1.4'
   spec.add_runtime_dependency 'uglifier', '~> 0.1'
-  #spec.add_runtime_dependency 'webrick', '~> 1.7.0'
+  # spec.add_runtime_dependency 'webrick', '~> 1.7.0'
   # the gem below are need to make the atome server works on Windows
   spec.add_runtime_dependency 'tzinfo-data', '~> 1.2023.4'
   spec.add_runtime_dependency 'win32-security', '~> 0.5.0'
 
-
   # Uncomment to register a new dependency of your gem
   # spec.add_dependency "example-gem", "~> 1.0"
 

data/exe/atome

@@ -8,6 +8,8 @@ require 'pathname'
 require 'opal'
 require 'parser'
 require 'uglifier'
+require 'rubygems'
+require 'gems'
 
 # utils
 
@@ -184,7 +186,6 @@ def create_application(source, destination, project_name)
 end
 
 def update_application(source, destination, project_name)
-  `gem install atome`
   project_path = "#{destination}/#{project_name}"
   FileUtils.mkdir_p(destination) unless Dir.exist?(destination)
   FileUtils.mkdir_p(project_path) unless Dir.exist?(project_path)
@@ -479,34 +480,58 @@ if ARGV.include?('create')
 end
 
 if ARGV.include?('update')
+  `gem install atome`
   # TODO: also update index.html and all other files except the application folder
-  # first we delete everything but application
+  # we check we are in atome app
+  if Dir.exist?("#{destination}/application") && !Dir.exist?("#{destination}/vendor")
+    # first we delete everything but application
 
-  files_to_treat = %w[server src-tauri src-wasm Guardfile Rakefile src/css src/js/atome src/js/third_parties src/medias
+    files_to_treat = %w[server src-tauri src-wasm Guardfile Rakefile src/css src/js/atome src/js/third_parties src/medias
 src/favicon.ico src/index_wasm.html src/index_opal.html src/index_server.html src/index_server_wasm.html]
-  files_to_treat.each do |item|
-    item_path = File.join(destination, item)
-    if File.directory?(item_path)
-      FileUtils.rm_rf(item_path) unless item == '.' || item == '..'
-    elsif File.file?(item_path)
-      File.delete(item_path)
+    files_to_treat.each do |item|
+      item_path = File.join(destination, item)
+      if File.directory?(item_path)
+        FileUtils.rm_rf(item_path) unless item == '.' || item == '..'
+      elsif File.file?(item_path)
+        File.delete(item_path)
+      end
+      source_item = "#{source}/vendor/assets/#{item}"
+      FileUtils.cp_r(source_item, item)
     end
-    source_item = "#{source}/vendor/assets/#{item}"
-    FileUtils.cp_r(source_item, item)
+    # now rebuilding aop lib
+    # build opal
+    build_opal_library(source, destination, project_name)
+    # build parser
+    build_opal_parser(source, destination, project_name)
+    # build atome kernel
+    build_atome_kernel_for_opal(source, destination, project_name)
+    # build host_mode
+    build_host_mode(destination, project_name, 'web-opal')
+    # build Opal extensions
+    build_opal_extensions(source, destination, project_name)
+    # build application
+    build_opal_application(source, destination, project_name)
+
+    ########################
+
+    # unless Dir.exist?("#{destination}/vendor")
+    #   Dir.mkdir("#{destination}/vendor")
+    # end
+
+    #######################
+
+    puts "your application is up to date"
   end
-  # now rebuilding aop lib
-  # build opal
-  build_opal_library(source, destination, project_name)
-  # build parser
-  build_opal_parser(source, destination, project_name)
-  # build atome kernel
-  build_atome_kernel_for_opal(source, destination, project_name)
-  # build host_mode
-  build_host_mode(destination, project_name, 'web-opal')
-  # build Opal extensions
-  build_opal_extensions(source, destination, project_name)
-  # build application
-  build_opal_application(source, destination, project_name)
+
+  # now we get the version of the atome gem
+  gem_name = 'atome'
+
+  # Obtenez les informations du gem depuis RubyGems.org
+  gem_info = Gems.info(gem_name)
+
+  # Extrait la version la plus récente du gem
+  latest_version = gem_info['version']
+  puts "#{gem_name} #{latest_version} is now installed "
 
 end
 
@@ -690,14 +715,14 @@ else
     build_opal_application(nil, destination, project_name)
     if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
       # code to exec with Windows
-       # `start #{destination}\\#{project_name}\\src\\index_server.html`
+      # `start #{destination}\\#{project_name}\\src\\index_server.html`
       `start   http://localhost:9292`
     elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
       # code to exec with MacOS
       `open http://localhost:9292`
     else
       # code to exec with Unix/Linux
-       `open http://localhost:9292`
+      `open http://localhost:9292`
     end
   end
 

data/lib/atome/version.rb

@@ -2,6 +2,6 @@
 
 #  return atome version
 class Atome
-  VERSION = '0.5.6.0.4'
+  VERSION =  '0.5.6.1.0'
 end
 

data/lib/atome.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# require 'eve'
 
 # require without relative is needed when using Opal
 require 'fileutils'
@@ -34,4 +33,5 @@ require 'renderers/html/index'
 require 'renderers/headless/index'
 require 'renderers/server/index'
 require 'atome/helpers/sanitizer'
+require 'eVe/eVe'
 require 'atome/genesis/sparkle'

data/lib/atome_relative.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# require 'eve'
 # relative is needed when using ruby wasm
 require 'fileutils'
 require 'securerandom'
@@ -33,4 +32,5 @@ require_relative './renderers/html/index_relative'
 require_relative './renderers/headless/index_relative'
 require_relative './renderers/server/index_relative'
 require_relative './atome/helpers/sanitizer'
+require_relative './eVe/eVe_relative'
 require_relative './atome/genesis/sparkle'

data/lib/eVe/LICENSE

@@ -0,0 +1,8 @@
+/*******************************************************
+ * Copyright (C) 2019-2020 atome http://atome.io
+ * 
+ * This file is part of atome.
+ * 
+ * eVe can not be copied and/or distributed without the express
+ * permission of atome
+ *******************************************************/

data/lib/eVe/README.md

@@ -0,0 +1,350 @@
+# eVe
+
+ ![](../ressources/icons/100.png)
+ 
+Cross platform development
+-
+
+To install application and run: 
+	
+Insert eVe project at the root of atome framework and run atome
+
+ 
+I - The framework
+- 
+
+- atome is a cross platform development environment.
+all apis work across all platform, to ensure the exact same rendering on Android, Freebsd, linux, MacOs, Web, Windows.
+
+- atome can create build web site, mobile or desktop applications, games, presentations...
+
+- atome is entirely open source as well as all the included libraries.you can do what you want want with it, the whole framework offer a permissive open source licence. 
+
+- atome comes with a powerful multi-rendering engine (it can render any atome object across several different render engine simultaneously )
+
+- atome's solutions can be deploy as a client, a server or both
+
+- the framework is totally hybrid, it means it can be executed in a web browser, a web view or as a full native application
+
+- ***(eVe only) when deploy as a server, any machine can host the server even without running, PHP , ruby, ...
+
+- any application created with it can be used as a data holder, in this case it behave like an universal multimedia document ( think pdf with sound , videos,  animations, interactivity, entirely scriptable, ....)
+
+- the powerful scripting engine can script any atome object on the fly at runtime.
+
+
+II Guideline and philosophy
+-
+
+The idea behind the atome concept is to have a kind of "universal portable intelligent document", this means : 
+
+- no filetype but instead unique objet called an atome (that could a text, an image, a group of object , a video, an efect, ..). This atome can then  be mnanipulated by any availlable api.
+
+The object uniq architecture bring us lot of new features:
+ 
+- Simplfly the automatisation of batch process as the object is always the same whatever it is (from a simple box thru a video montage to a complex page description) it's always an atome)
+- Simplfy the devellopment and tests of new tools. Ruby language allow you to script anything on the fly 
+- Reduce the number of tools needed for an application. (you dont ever have to wrote a specific tool for a specific medias anymore,  as the same tool now work on any atome.
+- and many many other ...
+to keep this idea working we have to follow the following rules during atome development :
+
+- All Apis must  run of all targeted platform (their should be no diiference form one platform to another.
+- any property or new api must always work on any type of atome, to keep the consistency of the  "atome uniq object" 
+
+III - main Open source Software included
+-
+- Cordova : a cross platform framework to create applications with web view rendering (https://cordova.apache.org)
+
+- Urho3D : is a cross platform 3D rendering and game engine used create native applications(or web rendering) using Webassembly (https://urho3d.github.io)
+
+- FreeBSD : is a Unix environment with jails, allow to create and boot embedded applications on any compatible machine (standard PC, Raspberry, Beaglebone, etc..) (https://www.freebsd.org/fr/)
+
+- Ruby : is the language used to script all atomes apis (https://www.ruby-lang.org)
+
+- Opal : is a ruby gem used to compile the ruby language to JS (https://opalrb.com)
+
+- Roda : is a ruby web framework that hold the server version of atome (https://roda.jeremyevans.net)
+
+- Puma : is a ruby web server to start the server version of atome (https://puma.io)
+
+- Jquery : is a js framework to simplify JS development (https://jquery.com)
+
+- ZimJS : is a html canvas rendering 2D engine (https://zimjs.com)
+
+- Konva : is a html canvas rendering 2D engine (https://konvajs.org)
+
+- FabricJS : is a html canvas rendering 2D engine (http://fabricjs.com)
+
+- ThreeJS :is a html canvas rendering 3D engine (https://threejs.org)
+
+- QAudio : a cross-platform C++ library for Audio Digital Signal Processing (https://cycfi.github.io/q/)
+
+
+IV - Architecture of the folders
+-
+The atome framework is mainly based on a Cordova project, but add the following additional features :
+
+- a ruby interpreter
+
+- a web server
+
+- a native mode with 3D rendering (the 3D engine is currently based on Urho3D).
+ 
+- a low latency audio system
+
+ -a bootable option for embedded applications
+
+The folders dedicated to the atome framework are : 
+
+- The app folder : contain all end user scripts
+
+- The atome folder : it contain the atome ruby's gem, this is basically the heart of the framework
+    - atome : this is the object it self
+        - atome class is found in the atome.rb files
+        - this class contain 5 main methods named SAGED for Set - Add - Get - Enliven - Delete 
+   
+    - proton : contain all the default property's value when creating new object
+   
+    - photon : contain all properties that define the physical aspect of the object to be renderer on a device, (visuals, sound , haptic...) ex: color, width
+   
+    - neutron :  contain all properties that are conceptual and do not need to be rendered in the view.
+     ex : selector, touch , child
+  
+    - electron : contain a collection of utilities (functions) to work easier with atomes's objects
+   
+    - big bang : initiate the atome environment 
+
+- The documentations folder : it contains infos and documentations of the framework ( how to install it , enhance it or use it )
+
+- The opal_compiler : contains two files:
+   
+    - opal_add_on.rb is a set of functions to enhance opal renderer, the parser
+    
+    - parser.rb is used to allow 'on the fly' atome scripting in the web view when using the opal compiler
+    
+- The renderers folder :contains any rendering engine such as :
+    
+    - html for pure js rendering
+    
+    - Headless for text only rendering of atome's objects
+    
+    - Vocals to render atomes as an audio description
+    
+    - Urho3D for native rendering 
+    
+    - FabricJS for 2D rendering in canvas's web view
+    
+    - ZIMJS for an alternative 2D rendering in canvas's web view
+    
+    - Konva for an alternative 2D rendering in canvas's web view
+    
+    - ThreeJS for 3D rendering in canvas's web view
+
+- The scripts folder contains all the files to automatise the install of atome framework
+
+- The rakefile file use to automatise the launch of atome framework
+
+- The index.js in www/public/js contains js functions and utility for the web rendering of atome engine
+
+- The index.html in www/public/ to initiate the web version of atome
+
+
+V - Rendering engine
+-
+
+ - NativeJS (web)
+ - ZimJS (web)
+ - Konva (web)
+ - FabricJS (web)
+ - ThreeJS (web)
+ - Urho3D (native or web with web assemebly)
+ - futur use case ( Unity, Unreal, Juce, ....)
+ 
+ 
+VI - running method
+  -
+
+- web (opal)
+- server (roda)
+- stand alone (Freebsd )
+- native (urho 3D)
+
+
+
+VII - what is an atome object
+ -
+ an atome is a collection of properties 
+ 
+ 
+- Anything that define an atome is a property.
+any atome can contain an other atome or a group of atomes as a property ex:
+ 
+ 
+    b=box()
+    i=image(:logo)
+    c=circle()
+    t=text("hello)
+    c.atome(b)
+    puts c.child #=> c (b is now a child of c
+    b.group([i,t])
+    puts b.child #=> [i,t] (i and t ares now a child of b
+    
+please note that child method is always singular, even when if it return many children! 
+ 
+The atome properties are always define using a key-value pair (Hash type). those values can be a String, an Integer, a hash(key-value) or an array. 
+The atome can receive a second optional parameters to refresh the view or not. 
+in this case the atome is till rendered in the view but the newly added parameters does not refresh the objet.
+(Please not the 'refresh option' behavior is not the same as the render property, the refresh option is used when a property is modify by the view it self we want to modification to be stored into the atome structure, but but want the view to be re-rendered)
+    
+- Any property can be define using an unique value (passed as a String , Symbole or a numeric  value) 
+
+
+    a=box({color: :red})
+    a.color(:red)
+    a.set({color: :red})
+    
+- Any property define are store internally as a Hash or an array if the property is define many times
+
+
+    a=box()
+    a.color(:red)
+    puts a.color #=> {color: :red}
+    
+ - to set a complex property such as shadow that needs more more than one parameters we have to send a hash to the atome
+ 
+ please note that any property can potentially have multiples parameters even the simplest one
+ 
+    a=box()
+    a.set({x: {content: 200, unit: :meters}) 
+   
+ - Any property are stackable (even the simplest one), in this case we used the 'add' method to stack prop. alternatively it's possible to used an array to stack properties
+ 
+ a simple gradient :
+   
+    b=box()
+    b.color([{color: :red, top: 0}, {color: :blue, bottom: 0}])
+     
+
+- all properties are treated identically and can be swap at any time.Type mutation is also possible : ex change the type of object from an image to text type 
+
+    x=image(:boat)
+    x.type(:text) #now the objet is rendered as a text object
+ 
+    
+here some possible definition of an atome
+
+
+    a=box({color: red}) # an red box is created
+    a.set(smooth: 3) # the box has rounded corner the view is refreshed
+    a.set({width: 250},true )# the box is now 250px wide the view is forced to refresh
+    a.set({border: :orange, thickness: 3}, false) #the atome is still red the view is not refreshed (no border!)
+    a.set([[color: :red, top: 20],[color: :blue, bottom: 0]], false) #the first parameters is an array that contain an array of color to allow a gradient , finally the view is not refreshed the atome remains 'red'.
+    a.color([{color: :yellow, top: 0}, {color: :orange, bottom: 0}]) # another way to set the atome property using the property name instead of using the 'set' methods, this time the view is refreshed
+    
+VIII - Enhancing the atome framework  
+   -    
+  
+how to create new type:
+ex create a "web" type
+
+- if a visuals are required for the new created, you have to add the following lines in the proton.rb file within 'module Proton':
+
+    
+    @@web = @@visual.merge(@@shape).merge(type: :web, preset: :web)
+    
+   
+the presets method create a new hash that hold the basics properties of the new atome type(in this case web type), it is need if you want to define the visual default representation of the type 
+
+- in proton.rb, the module Proton contains the  'presets' method you have to return the newly created ex:
+ return {box: box, circle: circle, text: text, image: image, video: video, audio: audio, particle: particle, tool: tool, web: web}
+ 
+
+- optionally you can define a new function that behave like a shortcut to create a preconfigured object. In this case a "web" function
+will create the shortcut. 
+ex add the following function in the big_bang.rb file:
+	(To be consistent the function should have the name of the newly created type)
+	
+	
+	 def web(options = nil)
+       if options && (options[:render]==false || options[:render]==:false )
+         refresh=false
+       else
+         refresh=true
+       end
+       atome = Atome.new(:web, refresh)
+       if options && (options.class == Symbol || options.class == String)
+         atome.send(:content, options)
+       elsif options && options.class == Hash
+         options.each_key do |param|
+           value = options[param]
+           atome.send(param, value)
+         end
+       end
+       return atome
+     end
+	
+	 
+ - neutron.rb file add the following lines :
+ 
+ 
+          def web params = nil, refresh = true, add = false
+            tag = :web
+            web = Atome.new(tag)
+            if params.class == String || params.class == Symbol
+              params = {content: params}
+            elsif params.class == Hash
+              self.child.each do |child|
+                if child.type == tag
+                  params.keys.each do |key|
+                    value = params[key]
+                    child.send(key, value)
+                  end
+                end
+              end
+            end
+            web.set(params)
+            self.group(web)
+            web.x(0)
+            web.y(0)
+            return web
+          end
+    
+          def web= params = nil, refresh = true, add = false
+            web(params, refresh, add)
+          end
+          
+          
+There two possibles ways to build an atome object:
+
+- using the Atome class     
+
+    a=Atome.new(:box)
+    
+
+- or the lazy the way using preset   
+
+    a=box()
+   
+   
+
+
+IX -  working with atome framework  
+-
+ any atome properties can be set using a unique value using the syntax below :
+ 
+    a=box()
+    a.color(:red) 
+    a.x=200
+    
+    
+you can send also the properties to the atome using parenthesis ou the equal sign:
+
+    a=box()
+    a.x(300)
+    a.y=500
+    
+    
+X - logic and datas flows
+-
+
+ 

data/lib/eVe/documentation/server.md

@@ -0,0 +1,2 @@
+# Adress atome.one : 
+5.196.69.103

data/lib/eVe/eVe.rb

@@ -0,0 +1 @@
+puts "so cool!!!"

data/lib/eVe/eVe_relative.rb

@@ -0,0 +1 @@
+puts "so good!!!"

data/lib/eVe/todo.txt

@@ -0,0 +1,147 @@
+
+Urgent :
+            - Drag and drop
+            - Save
+            - user strategy
+            - U.I.
+            - IDE
+            - Embeded versionnb v
+
+ tool composition tool :
+  - Examples
+  - Api name
+  - Definition
+  - usages
+  - copyright
+  - price
+  - Author
+  - presets
+  - connex tools
+  - code
+  - version of Api
+- create a two way return method. ex : e.x => 50 e.x_incept => {content: :50, dynamic => true, reference: :view}
+- suppress all  @@ class varaible
+- find a solution when setting text if we want to position it corecctly and obtain the correct size using the value api when have to set prop in this order:find a way to set the prop in any order : text_title.width(:auto)
+                                                                                                                                                                                                      text_title.x = 80
+                                                                                                                                                                                                      text_title.xx = 80
+                                                                                                                                                                                                      text_title.y = 0
+- add adaptive size: for width and height too:
+- create method accumulate so the next obect is postioned after the precedent etheir along x or y axis, with an optional offset
+- to modify text lines aligenments t.child.align(:distribute/x/xx, center)                                                                                                                                                                                                   text_title.size(34)
+- bug when inserting an object into another if the insertted object is centererd before grouping its position is incorect
+- change width according to the right align
+- enliven still need a bit od refinement
+- to test: read_code in help.rb ( reactive the commented lines)
+- if object position is specified using xx then when dragging it should remain relative to xx not to x
+- todo objet masking and stencil with boolean
+- bug width anim help error with border radius
+- add or check if a delete property exist and relaly delete the property and it's value
+- bug text menu on resize start in method render_resize in html.rb file
+- finish to add monitor to all apis
+- verify object in object
+- check old group method for group in group!!
+- create detach method
+- .bat script on windows to install atome
+- check group add child nd parent respectively
+- check ungroup both remove parent and child property
+- unify (group/child) - (attach-parent) (detach-ungroup)
+- Help.render bug, Help.volume_example bug
+- reflection if presets are global or specific to a atype , cf preset :red only available for color or also for text
+- allow to create new preset
+- Better alert system
+- create objext in object example
+- create rotation example
+- finish attach api (group inverse)
+- Important : Objet created in objet are not centered anymore!!
+- Important : check if event are re-injected when setting events before sending type to the view
+- create a console  objet and redirect the js console to the new console
+- bug when enliven a draggable object
+- bug when enliven an object whith children. Children are nor enliven
+- add Urho 3D rendering (Mruby)
+- Arduino (shell acces from cordova)
+- Create menu
+- U.I.
+- Save mecanism (DB and file)
+- check Roda and native Ruby
+- websocket
+- restore ide
+- create console
+- Add Q-Audio native library binding
+- remove all comment when creating production version
+- Kind of bug, if we run the script 'default_values' in Help then the 'enliven' script position are not consistent because the position is first set using x and then override by left and top (is it a bug?)
+- record media
+- allow iframe integration
+- object type permutation
+- Help.drag bug object are persistent when modifying or re running the script
+- drag api  is badly formated and not send the same manner to the render when restoring from @drag other event api with proc may have the same propblem
+- when using b=box(); c=b.circle({x: 20}) objet are badly positioned
+- text tabulation is rendered
+- Align bug for text
+- unify all finite value with value 0 to 1
+- render_fill bug when using % or px (html.rb line 308 - 317
+- enhancement check Preset algorythm behavior, it should create an atome accordingg to the type then  apply the preset's optional proprties (also check if the type and the  the presetare corectly fromated and saved)
+- bug when changing image content if a size  it is reset
+- better integration of web iframe
+- image can't be created using Atome.new({"id"=>"logo", "type"=>"image", "content"=>"atome", "preset"=>"box", "size"=>33.33333333333333, "top"=>8.333333333333334, "left"=>8.333333333333334, "shadow"=>{"color"=>"rgba(0,0,0,0.3)", "blur"=>16, "x"=>0, "y"=>0}})
+- rename drag event page_x to x
+- out api (when over)
+- ensure atome_id unicity
+- drag api on mobile kill any touch set before the drag but doesn't on desktop
+- conflict between get(id) and atome.get
+- anim callback
+- internationalisation
+- multi render engine
+- group store only the iD of the object grouped not the atome
+- add dynamic option to center api to allow recentering on resize
+- add an offset option when using the center api
+- add target option to center api to allow centering according to another object
+- parent api should return the id instead of the atome_id to be easier for coder
+- bug : when writing b=box();b.x=b.y=300;alert b.info.join("\n") it crash
+- add rotation pivot option
+- infos tools
+- select tool
+- Make tests
+- unify unit ( 0 to 1) for all values
+- change color so when a user specify a purple color it create a "purple" preset, the atome then look like this :
+[type: :shape, preset: :box, red: [child: :purple],green: [child: :purple],blue: [child: :purple],alpha: [child: :purple],cyan: [child: :purple],magenta: [child: :purple],yellow: [child: :purple],key: [child: :purple]]
+- anim param as a block and param used to acitvate desavtivate anim : b.anim(true) do |evt|; start: {x: 0}, end: {x: 200}, duration: 150, target: b.id; end
+- Collaboration
+- User account
+- Rights managements
+- Multidevice acccount access and datas retreive
+- import asset with drag an drop
+- Int8!
+- Accessibility
+- keep current content in event  (allow the use of self in bloc) proc.call(evt) if proc.is_a?(Proc) #instance_eval(&proc) if proc.is_a?(Proc)
+- on overflow
+- name and store events in a list to remove those events by their names
+
+- remove all code in backtick from html.rb file
+- pb de css filter qui s'efface le precedent quand on en ajoute un nouveau
+
+
+eVe Tools to do :
+done - bug with Help module and topic name if topic is an atome function etheir the topic is not display or the atome methode doesnt work
+pone - bug if help is call before background the app is freeze
+done - pb drag  ex a.drag(true) (sans bloc do end)
+done - remove jquery UI css error
+done - add romain Arc
+done - put all render methods in html.rb file in a module
+done - delete child when deleting group
+done - clean up code
+done - correct deletion strategy for object
+done - on resize (for view)
+done - Allow youtube integration
+done - replace refresh by render property in atome api ex: box({color: :red, render: false})
+done - bug in 'every' api that stop after 5 times
+done - Help.render crash the help application
+done - finish fit function
+done - catch eror when a media is messing to avoid : "[]: undefined method `[]' for nil"
+done - add_prop_to_all child crash
+done - allow default value for atome to be parametric
+done - verify selectable is possible( for objet and text)
+Done - a regression prevent resurection to work
+Done - refresh rake compile when modifying atome libs
+done - resize method (scale)
+Done - puts render in a class Render with optional rendering engine( mfor multiples simultaneaous rendering)
+Done - puts the render methods in a  module

data/lib/platform_specific/opal/opal.rb

@@ -2,3 +2,4 @@
 
 # render methods
 require 'opal'
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: atome
 version: !ruby/object:Gem::Version
-  version: 0.5.6.0.4
+  version: 0.5.6.1.0
 platform: ruby
 authors:
 - Jean-Eric Godard
@@ -10,6 +10,34 @@ bindir: exe
 cert_chain: []
 date: 2024-02-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: artoo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+- !ruby/object:Gem::Dependency
+  name: eVe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: eventmachine
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: gems
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: guard-rake
   requirement: !ruby/object:Gem::Requirement
@@ -388,7 +430,6 @@ files:
 - exe/atome
 - lib/atome.rb
 - lib/atome/atome.rb
-- lib/atome/eve.rb
 - lib/atome/extensions/atome.rb
 - lib/atome/extensions/geolocation.rb
 - lib/atome/extensions/mathematics.rb
@@ -433,6 +474,13 @@ files:
 - lib/atome/presets/atome.rb
 - lib/atome/version.rb
 - lib/atome_relative.rb
+- lib/eVe/LICENSE
+- lib/eVe/README.md
+- lib/eVe/documentation/Backup_docs.zip
+- lib/eVe/documentation/server.md
+- lib/eVe/eVe.rb
+- lib/eVe/eVe_relative.rb
+- lib/eVe/todo.txt
 - lib/platform_specific/opal/atome_opal_extensions.rb
 - lib/platform_specific/opal/extensions/color.rb
 - lib/platform_specific/opal/extensions/geolocation.rb