atome 0.1.00009 → 0.4.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4b48cdeb89c228abfd54f7ff8a986bf57b856ee448248f8bc72d350f2102f92
-  data.tar.gz: 684ee3dbfb0c2f8a630203b70c76fee2c4bbc38e668236eb39ce4031fce07ad0
+  metadata.gz: 49cc8d868d75099b8958e82985a3fbf1c43eaea349619ffa01e810fd9ea10ca0
+  data.tar.gz: 5e9b7460dea168d8fb9b21de448edbb57deed81173fc1d04bf95f12262e80ba7
 SHA512:
-  metadata.gz: abce3a0481ef173040bff4c5753ddc0da3429b62b9d25c6b60b3dd87751b582d3c917fb84ed56b97b684fe8066ff99882f7be57a1530529f32eee02666fa2781
-  data.tar.gz: e1addd8946eed935d0becf3b612969387f6107271819913fc62a8fe0f633ed13f485974195f77f74f28c03e95c412af39171336efcde841683e3ee84337eef29
+  metadata.gz: 12f981205e19cfc5f4243e8498c190b7b5903009660f0c68219c4eaee95195b47e0ff69fcecc67c69cd7624b66a8dd10340249dc7bc9576682d05031ec497ed3
+  data.tar.gz: ee6814778ba2ca00d75a7fb714847c680982ce20ffccc2df34160554340f1cb400efaab3a996d1820e91879ba72a0430f5bd90c2eb2463c39a25a2e1becdc540

data/Gemfile

@@ -8,3 +8,7 @@ gemspec
 gem "rake", "~> 13.0"
 
 gem "minitest", "~> 5.0"
+gem 'rubocop', group: 'development'
+gem 'rubocop', group: 'development'
+gem 'rubocop', group: 'development'
+gem 'rubocop', group: 'development'

data/README.md

@@ -1,8 +1,64 @@
-# Atome
+Atome
+-
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/atome`. To experiment with that code, run `bin/console` for an interactive prompt.
+<img src="./documentation/images/3.png" width="666" />
+-
 
-TODO: Delete this and the text above, and describe your gem
+
+Cross platform ecosystem
+-
+
+- atome is a cross platform development framework, aim to build mobile or desktop applications, web site, games, presentations, and lots more...
+
+- atome's applications can be deploy as a simple application, a client, a server or both, as well as be booted at startup (Operating System. mode)
+
+- all apis work identically, to ensure you'll have the exact same rendering whatever the host platform (Android, Freebsd, linux, MacOs, Web, Windows).
+
+- atome and all the included libraries are entirely open source with a very permissive MIT licence. it means you can do what you want want with it!
+
+- the framework is totally hybrid, it can be executed as a full blown native application, a native application with a web view, in a web browser or a web view
+
+- Atome can be used in stand alone (offline mode), in cloud mode or both and sync data when required
+
+- it's also possible to publish websites on a static server (without server side language) while using a database and sync data between users
+
+- Anything in atome can be scripted, even on the fly at runtime!
+
+Open source technology included
+-
+
+- Ruby : is the language used to script all atome's apis (https://www.ruby-lang.org)
+
+[comment]: <> (<img src="https://github.com/atomecorp/atome/raw/master/documentation/images/logos/ruby.png" width="100" />)
+
+- Opal : is a ruby gem used to compile the ruby language to JS (https://opalrb.com)
+
+[comment]: <> (<img src="https://github.com/atomecorp/atome/raw/master/documentation/images/logos/opal.png" width="100" />)
+
+- Roda : is a ruby web framework that push the server version of atome (https://roda.jeremyevans.net)
+
+[comment]: <> (<img src="https://github.com/atomecorp/atome/raw/master/documentation/images/logos/roda.svg" width="100" />)
+
+- Puma : is a ruby web server to start the backend of atome (https://puma.io)
+
+[comment]: <> (<img src="https://github.com/atomecorp/atome/raw/master/documentation/images/logos/puma.png" width="100" />)
+
+- FreeBSD : is a Unix platform with a very secure environment (jails), allow to create and boot embedded applications on any compatible machine (standard PC, Raspberry, Beaglebone, etc..), while keeping a very small footprint using the nanoBSD facility of FreeBSD (https://www.freebsd.org/fr/)
+
+[comment]: <> (<img src="https://github.com/atomecorp/atome/raw/master/documentation/images/logos/freebsd.png" width="100" />)
+
+- Tauri : Build smaller, faster, and more secure desktop applications with a web frontend.(https://github.com/tauri-apps/tauri)
+
+[comment]: <> (<img src="https://avatars.githubusercontent.com/u/54536011?s=200&v=4" width="100" />)
+
+<img src="./documentation/images/logos/ruby.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+
+[//]: # (<img src="./documentation/images/logos/cordova.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;)
+<img src="./documentation/images/logos/opal.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+<img src="./documentation/images/logos/roda.svg" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+<img src="./documentation/images/logos/freebsd.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+<img src="./documentation/images/logos/puma.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+<img src="./documentation/images/logos/tauri.png" width="100" />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 
 ## Installation
 
@@ -16,7 +72,7 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
-TODO: Write usage instructions here
+[Full documentation here](./documentation/atome.md)
 
 ## Development
 
@@ -26,7 +82,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/atome. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/atome/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/atomecorp/atome. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/atomecorp/atome/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -34,4 +90,16 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Atome project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/atome/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Atome project's codebase, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/atomecorp/atome/blob/master/CODE_OF_CONDUCT.md).
+
+
+Example website:
+-
+**[a website showing some apis demo ](http://atome.one)**
+
+
+Contact:
+-
+**[queries@atome.one](mailto:contact@atome.one)**
+
+<img src="./documentation/images//atome.svg" width="100" />

data/Rakefile

@@ -1,12 +1,20 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rake/testtask"
+#old code below
+# require "bundler/gem_tasks"
+# require "rake/testtask"
+#
+# Rake::TestTask.new(:test) do |t|
+#   t.libs << "test"
+#   t.libs << "lib"
+#   t.test_files = FileList["test/**/test_*.rb"]
+# end
+#
+# task default: :test
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/test_*.rb"]
+task :test do
+  `gem cleanup atome;yes | gem uninstall atome ;gem build atome.gemspec;gem install atome`
+  `cd test/test_app;atome update;atome run guard`
 end
 
 task default: :test

data/app_builder_helpers/Rakefile

@@ -1,65 +1,223 @@
 # frozen_string_literal: true
 
+# FIXME: check when creating gem version the new gem is not always fully updated we have to type gem uninstall first
+
 require 'opal'
 require 'opal-jquery'
 require 'opal-browser'
 require 'parser'
+require 'ruby2js'
 require 'uglifier'
 
 Opal.append_path 'app'
 
-def build_opal_browser(user_project_path, production = false)
-  browser_js = "#{user_project_path}/build/js/opal/opal_browser.js"
-  browser_content = Opal::Builder.build('../lib/atome/renderers/opal/opal_browser.rb').to_s
-  browser_content.gsub!("$$$('STDERR')['$write_proc='](typeof(process) === 'object' && typeof(process.stderr) === 'object' ? function(s){process.stderr.write(s)} : function(s){console.warn(s)});", "$$$('STDERR')['$write_proc='](typeof(process) === 'object' && typeof(process.stderr) === 'object' ? function(s){process.stderr.write(s)} : function(s){});")
-  browser_content = Uglifier.new.compile(browser_content) if production
+def build_browser_content
+  Opal::Builder.build('../lib/atome/renderers/opal/opal_browser.rb').to_s
+end
+
+def build_opal_browser(user_project_path)
+  opal_directory = "#{user_project_path}/build/js/opal"
+  browser_js = "#{opal_directory}/opal_browser.js"
+  Dir.mkdir(opal_directory) unless File.directory?(opal_directory)
+
+  File.new browser_js, 'w'
+  browser_content = build_browser_content
+
   File.open(browser_js, 'w') do |f|
     f.puts browser_content
   end
 end
 
-def build_atome_kernel(user_project_path, gem_location, production = false)
-  kernel_js = "#{user_project_path}/build/js/atome/kernel.js"
+def build_aui(user_project_path)
+  # FIXME: for now production can't be change when updating or force create, we should add a production method that
+  # uglified all libs on demand
+
+  #  now we add an uniq aui to the app
+  aui_js = "#{user_project_path}/build/js/aui.js"
+  File.new aui_js, 'w'
+  builder = Opal::Builder.new
+  aui_content = builder.build("#{user_project_path}/aui.rb").to_s
+  File.open(aui_js, 'w') do |f|
+    f.puts aui_content
+  end
+end
+
+def copy_assets_files(user_project_path, gem_location)
+  build_location = "#{gem_location}/../vendor/assets/build/"
+  server_location = "#{gem_location}/../vendor/assets/server/"
+  FileUtils.copy_entry build_location, "#{user_project_path}/build", preserve: nil
+  FileUtils.copy_entry server_location, "#{user_project_path}/server", preserve: nil
+end
+
+def build_atome_kernel(user_project_path, gem_location)
+  #  now lets build the atome kernel
+  atome_directory = "#{user_project_path}/build/js/atome"
+  Dir.mkdir(atome_directory) unless File.directory?(atome_directory)
+  kernel_js = "#{atome_directory}/kernel.js"
+  File.new kernel_js, 'w'
   builder = Opal::Builder.new
   builder.append_paths("#{gem_location}/../lib/")
   kernel_content = builder.build("#{gem_location}/../lib/atome.rb").to_s
-  kernel_content = Uglifier.new.compile(kernel_content) if production
   File.open(kernel_js, 'w') do |f|
     f.puts kernel_content
   end
 end
 
-def build_opal_parser(user_project_path, production = false)
+def build_opal_extensions(user_project_path, gem_location)
+  opal_directory = "#{user_project_path}/build/js/opal"
+  extensions_js = "#{opal_directory}/atome_opal_extensions.js"
+  File.new extensions_js, 'w'
+  builder = Opal::Builder.new
+  builder.append_paths("#{gem_location}/../lib/atome/renderers/opal/")
+  extensions_content = builder.build("#{gem_location}/../lib/atome/renderers/opal/atome_opal_extensions.rb").to_s
+  File.open(extensions_js, 'w') do |f|
+    f.puts extensions_content
+  end
+end
+
+def build_opal_parser(user_project_path)
   parser_js = "#{user_project_path}/build/js/opal/opal_parser.js"
+  File.new parser_js, 'w'
   parser_content = Opal::Builder.build('../lib/atome/renderers/opal/opal_parser.rb').to_s
-  parser_content = Uglifier.new.compile(parser_content) if production
   File.open(parser_js, 'w') do |f|
     f.puts parser_content
   end
 end
 
-def build_user_code(user_project_path, production = false)
+def build_user_code(user_project_path, source_code)
   application_js = "#{user_project_path}/build/js/application.js"
-  application_content = Opal::Builder.build('../vendor/assets/index.rb').to_s
-  application_content = Uglifier.new.compile(application_content) if production
+  builder = Opal::Builder.new
+  builder.append_paths("#{user_project_path}/")
+  application_content = builder.build(source_code).to_s
+
   File.open(application_js, 'w') do |f|
     f.puts application_content
   end
 end
 
-task :system_builder do
-  # change to false for not production mode and faster compile time
-  production = false
-  user_project_path = ARGV[1]
-  gem_location = File.join(File.dirname(__FILE__))
-  build_atome_kernel(user_project_path, gem_location, production)
-  build_opal_browser(user_project_path, production)
-  build_opal_parser(user_project_path, production)
-  build_user_code(user_project_path, production)
+def minimize_aui(user_project_path)
+  aui_js = "#{user_project_path}/build/js/aui.js"
+  aui_content = File.open(aui_js).read
+  aui_content = Uglifier.new.compile(aui_content)
+  File.open(aui_js, 'w') do |f|
+    f.puts aui_content
+  end
+end
+
+def minimize_browser(user_project_path)
+  browser_js = "#{user_project_path}/build/js/opal/opal_browser.js"
+  browser_content = File.open(browser_js).read
+  browser_content = Uglifier.new.compile(browser_content)
+  File.open(browser_js, 'w') do |f|
+    f.puts browser_content
+  end
 end
 
-task :build do
-  puts 'nothing for now'
+def minimize_parser(user_project_path)
+  parser_js = "#{user_project_path}/build/js/opal/opal_parser.js"
+  parser_content = File.open(parser_js).read
+  parser_content = Uglifier.new.compile(parser_content)
+  File.open(parser_js, 'w') do |f|
+    f.puts parser_content
+  end
+end
+
+def minimize_atome_lib(user_project_path)
+  atome_js = "#{user_project_path}/build/js/atome/kernel.js"
+  atome_content = File.open(atome_js).read
+  atome_content = Uglifier.new.compile(atome_content)
+  File.open(atome_js, 'w') do |f|
+    f.puts atome_content
+  end
+end
+
+def minimize_sparkle(user_project_path)
+  opal_sparkle_js = "#{user_project_path}/build/js/opal/opal_sparkle.js"
+  opal_sparkle_content = File.open(opal_sparkle_js).read
+  opal_sparkle_content = Uglifier.new.compile(opal_sparkle_content)
+  File.open(opal_sparkle_js, 'w') do |f|
+    f.puts opal_sparkle_content
+  end
+end
+
+def minimize_opal_extensions(user_project_path)
+  atome_opal_extensions_js = "#{user_project_path}/build/js/opal/atome_opal_extensions.js"
+  atome_opal_extensions_content = File.open(atome_opal_extensions_js).read
+  atome_opal_extensions_content = Uglifier.new.compile(atome_opal_extensions_content)
+  File.open(atome_opal_extensions_js, 'w') do |f|
+    f.puts atome_opal_extensions_content
+  end
+end
+
+def minimize_libraries(user_project_path)
+  # minimizing aui
+  minimize_aui(user_project_path)
+  # minimizing opal_browser
+  minimize_browser(user_project_path)
+  # minimizing opal_parser
+  minimize_parser(user_project_path)
+  # minimizing atome_lib
+  minimize_atome_lib(user_project_path)
+  # minimizing atome_lib
+  minimize_sparkle(user_project_path)
+  # minimizing atome_lib
+  minimize_opal_extensions(user_project_path)
+end
+
+def minimize_user_code(user_project_path)
+  # minimizing user codes
+  application_js = "#{user_project_path}/build/js/application.js"
+  application_content = File.open(application_js).read
+  application_content = Uglifier.new.compile(application_content)
+  File.open(application_js, 'w') do |f|
+    f.puts application_content
+  end
+end
+
+task :build_user_code, :user_project_path, :production do |_t, args|
+  user_project_path = args[:user_project_path]
+  production = args[:production]
+  source_code = "#{user_project_path}/application/index.rb"
+  build_user_code(user_project_path, source_code)
+  minimize_user_code(user_project_path) if production == 'production'
+end
+
+task :system_builder, :user_project_path, :production do |_t, args|
+  user_project_path = args[:user_project_path]
+  production = args[:production]
+  source_code = '../vendor/assets/application/index.rb'
+  build_common_libraries(user_project_path, production)
+  build_user_code(user_project_path, source_code)
+
+  # TODO: catch and message to user when when there's no force and folder already exist
+end
+
+task :system_updater, :user_project_path, :production do |_t, args|
+  user_project_path = args[:user_project_path]
+  production = args[:production]
+  build_common_libraries(user_project_path, production)
+end
+
+task default: :run
+
+def build_libraries(user_project_path, gem_location)
+  build_aui(user_project_path)
+  build_atome_kernel(user_project_path, gem_location)
+  build_opal_browser(user_project_path)
+  build_opal_parser(user_project_path)
+  build_opal_extensions(user_project_path, gem_location)
+end
+
+def minimize(user_project_path)
+  minimize_libraries(user_project_path)
+  minimize_user_code(user_project_path)
+end
+
+def build_common_libraries(user_project_path, production)
+  gem_location = File.join(File.dirname(__FILE__))
+  copy_assets_files(user_project_path, gem_location)
+  build_libraries(user_project_path, gem_location)
+  minimize(user_project_path) if production == 'production'
 end
 
-task default: :build
+# TODO: integrate pure JS (ruby2js) compilation

data/documentation/atome.md

@@ -0,0 +1,14 @@
+ atome
+ -
+
+ <img src="./images/atome.svg" width="100" />
+
+***Documentation***
+-
+
+**[I - What is atome](./framework/what_is_it.md)**
+
+**[II - How to use it](./tutorials/tutorials.md)**
+
+**[II - how to enhance](./framework/technical/technical_description.md)**
+

data/documentation/framework/apis.md

@@ -0,0 +1,14 @@
+<span align="right">
+
+[Main menu](../atome.md)
+-
+</span>
+<span align="left">
+
+[back](./what_is_it.md)
+
+</span>
+
+Datas flows :
+-
+ 

data/documentation/framework/atome_explained.md

@@ -0,0 +1,179 @@
+
+<span align="right">
+
+[Main menu](../atome.md)
+-
+</span>
+
+atome explained : the uniq object format
+-
+
+ # new atome format
+
+----------------
+atome structure :
+id: {hash: {key: : value}
+aui : {atome: {property: value}
+
+ex: a_01: {color:{x: 33, y: 69, red: 0.1, green: 0.2, blue: 1, alpha: 1: diffusion: :radial}}
+
+user can write: 
+a.color(:red)
+a.red(0.1)
+a.color(color:{x: 33, y: 69, red: 0.1})
+
+
+
+an atome is a  property ( position, size, type, etc..)
+
+a single property (atome) can hold multiples properties cf: child property
+
+    b=box({ drag: true, atome_id: :the_box })
+    t=text({ content: "touch me to extract me from the box,\nand attach me to the circle ",y: 99, atome_id: :the_text  })
+    grab(:the_box).attach(:the_text)
+    puts  b.child # =>  ["the_text"]
+    
+
+atome's property are mutable even it's type ( useful to display a same atome in different manner, or use the data of the atome as a repository of style, or simply sawp it's functionality while retaining it's properties) 
+
+a single atome can be displayed in different way according it's rendering mode and or it's type. 
+
+EG :
+    
+
+    a=image(content: :moto)
+
+
+<img src="https://github.com/atomecorp/atome/raw/development/www/public/medias/images/moto.png" width="333" />
+
+    a.color(:white) #important else the text xill be transparent
+    a.type(:text)
+moto
+
+    a.render({mode: :list, list: :property, sort: :alphabetically })
+<img src="https://github.com/atomecorp/atome/raw/development/documentation/images/list.png" width="400px" />
+
+
+
+- Anything that define an atome is a property.
+  any atome can contain an other atome or a group of atome as a property ex :
+
+
+    b = box({x: 300, drag: true})
+    image(:logo)
+    c = circle(x: 100)
+    b.insert(c.atome_id)
+    b.text('hello')
+    puts b.child #=> [c, t] (c and t is now a child of b)
+    b.touch do
+    # b children can be treated in one pass
+    # look at child example for more examples
+    b.child.color(:green)
+    end
+
+Many atome properties can be set using a string or integer, it's a shortcut to set the content property eg :
+
+    text("hello") # equivalent to text({content: "hello"})
+    # or
+    image(:boat) # shortcut for image({content: :boat})
+
+internally properties are always define using a key-value pair (Hash type) and can be set so :
+
+    text({content: "hello"})
+
+Hash's values can be a String, an Integer, a hash or an array.
+
+The atomiser method allow to modifying atome without interpreting/ refreshing the newly set property.
+in this case the atome need rendered to refresh it's content
+
+    b = box()
+    b.atomiser({ color: :red })
+    b.atomiser({ smooth: 6})
+
+    wait 2 do
+      b.render(true)
+    end
+
+
+- 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}
+  
+- multiples parameters can be set at once using a hash:
+  
+
+    box({x: 96, y: 96, color: :red, blur: 3})
+
+- an object can be add as/like a property
+
+
+    box({text: :hello})
+    #or 
+    b=box(x: 200)
+    b.text("hello")
+
+- methods can be chained or assigned 
+
+
+    b=box(width: 33)
+    b.color(:red).x(96).blur(3)
+
+    #or
+    b=box(width: 33)
+    b.color(:red).x(96).blur(3)
+    c=circle(color: :red)
+    b.color=c.color
+    c.y=b.blur
+      
+
+
+
+
+- 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
+
+    # not implemented need a rework
+    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([:cyan, :green, :orange, {diffusion: :conic}])
+
+
+- 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({color: :white, content: :boat })
+    ATOME.wait 2 do
+    x.type(:text) #now the objet is rendered as a text object
+    end
+
+
+
+here some possible definition of an atome
+
+    a=box({color: :red}) # an red box is created
+    a.set(smooth: 9) # 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: { color: :orange, thickness: 7, pattern: :solid } })
+
+**[- Architecture of the folders](./folder_architecture.md)**
+-
+
+**[- logic and datas flows](./datas_flows.md)**
+-

data/documentation/framework/box_content.md

@@ -0,0 +1,53 @@
+<span align="right">
+
+[Main menu](../atome.md)
+-
+</span>
+<span align="left">
+
+[back](./what_is_it.md)
+
+</span>
+
+What's in the box
+-
+
+
+**The atome framework is based on the Cordova framework, plus the additional following features :**
+
+
+
+- a ruby interpreter
+
+- a web server mode
+
+- a simple modular and consistent syntax to build your own environment and tools
+
+  
+- video recording playback and streaming
+
+- video conference
+
+- realtime collaborative tool
+
+- a bootable option for embedded applications on both AMD64 and ARM
+
+- a full set of APIs covering graphics, audio, file, database and multimedia facilities (animation, interactive, drawing)
+
+- everything in atome can be scriptable even at run time 
+
+- a native 3D engine rendering (the 3D engine is currently based on Urho3D, more frameworks may be supported in the future).
+
+- a low latency audio system based on QAudio framework
+
+- the atome object concept, that'll allow any to alter any object tools whatever it's type  (unique Object concept)
+
+- modular set of tools to create and modify atomes
+
+- All tools alteration  are non destructive
+  
+- atome alterations are logged so it's possible to restore an atome at any point of it's life
+
+- expendable API system
+
+- and more ...