atome 0.1.00009 → 0.4.5.4

data/documentation/tutorials/first_steps.md

@@ -0,0 +1,148 @@
+<span align="right">
+
+[Main menu](../atome.md)
+-
+</span>
+<span align="left">
+
+[back](./tutorials.md)
+
+</span>
+
+Now create your first app:
+-
+
+first type the following command in your shell
+
+    atome create myproject
+
+This will create a folder named "myproject" that'll hold your application
+
+in this newly created folder you'll find folder name "application".
+
+open it and it the file named "index.rb" adding the text below :
+
+    text("hellow world!")
+
+you're application is ready to run, to do so, in your shell type the following command:
+
+    cd myproject
+    atome run
+
+
+then your default browser should open and display the "hello world!" text
+
+
+Now lets build some atomes
+-
+
+This easiest way to build is to use the basic api such as the text api used just before :
+
+    text("hellow world!")
+
+below here is how build an atome box and assign a variable
+
+    a=box()
+
+You can also build and Atome using the Atome class
+-
+This is a more complex way to build atome but way a faster for the machine to process 
+
+    a=Atome.new({preset:box)}
+
+# Here are a few common commands
+
+
+# 1 - Create a new app
+
+in your terminal type :
+
+    atome create myproject
+
+or atome create :
+
+    atome create myproject production
+for production mode (all javascript file will be minimized and uglified)
+
+
+to overwrite an existing project :
+
+    atome create myproject production force
+
+# 2 - Run the application
+
+go into the project :
+
+    cd myproject
+
+# Run the project :
+
+browser version
+
+- Warning : run the app doesn't refresh the user code, to refresh use the command 'build'
+
+
+    atome run browser
+
+
+server version 
+
+- Warning : run the app doesn't refresh the user code, to refresh use the command 'build'
+   
+  
+    atome run server
+
+- By default the address port is 9292 : http://localhost:9292/index
+
+
+gem version
+
+    require 'atome'
+    a=Atome.new
+    puts a.inspect
+
+native version : android , iOS, Linux, windows 
+
+- Warning : run the app doesn't refresh the user code, to refresh use the command 'build'
+ 
+    
+    atome run osx
+
+OS version
+
+
+    go to https://github.com/atomecorp/atomic_builder
+
+
+to run in production mode (faster server mode)
+
+    atome run server production
+
+to update your application ti the latest atome version
+
+    gem update
+    atome update
+
+to set the server port
+
+    atome run server port: 9299
+
+Supported platforms with the run command are : browser, server , android, Freebsd, iOS, OSX, Windows
+
+    atome run osx
+
+# compile the user app :
+
+to build your app and re-generate javascript script from ruby type:
+
+    atome build 
+
+for production mode (compressed and uglified javascript files) type :
+
+    atome build production
+
+Please note, is possible to mix multiple options to create run and set some options in one pas:
+
+     atome create myproject server force run production port: 9293
+
+

data/documentation/tutorials/tutorials.md

@@ -0,0 +1,15 @@
+<div align="right">
+
+[Main menu](../atome.md)
+-
+</div>
+
+**[- first steps](./first_steps.md)**
+-
+
+**[- working with atome framework  (developers)](./working_with_atome.md)**
+-
+
+**[- enhance_atome](./enhance_atome.md)**
+-
+

data/documentation/tutorials/working_with_atome.md

@@ -0,0 +1,60 @@
+<span align="right">
+
+[Main menu](../atome.md)
+-
+</span>
+<span align="left">
+
+[back](./tutorials.md)
+
+</span>
+
+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
+
+The basic objects
+
+those objects are created by the system at startup : 
+-
+
+- preset :  hold the default properties's values for predefined atome  ( box, image text, ...)
+
+- black_hole : a container for all deleted object
+
+- device : Used to identify user device (computer , phone , tablet), also used for Namespace and generate identity of newly created atomes
+
+- intuition : A visual layer used to hold user tools
+
+- view : Where user create and modify there projects
+
+- messenger : A special object used for communication and collaboration
+
+- authorization : this atome is used to authorise or not creation , use, communication and modification of atome
+
+buffer : an atome used to store temporary object, it is used to store temporary element such as  the position and content of system element like the code editor or the list of element to remain centered when the main windows is resized,
+eg:
+
+
+    b = box({ width: 700, height: 120, drag: true, center: { dynamic: true } })
+    c = circle
+    t = text({ content: "ok", color: :black, center: :x })
+
+    grab(:buffer).content[:resize] = [t, b]
+    ATOME.resize_html do |evt|
+        t.content("#{evt[:width]}  #{evt[:height]}")
+            grab(:buffer).content[:resize].each do |element|
+            element.center=element.center
+        end
+    end

data/exe/atome

@@ -2,60 +2,66 @@
 # frozen_string_literal: true
 
 require 'fileutils'
+require 'securerandom'
+require 'digest/sha2'
+# below are the methods needed for atome creation and run
 
-def delete_all(dir)
-  Dir.foreach(dir) do |e|
-    # Don't bother with . and ..
-    next if %w[. ..].include? e
-    fullname = dir + File::Separator + e
-    if FileTest.directory?(fullname)
-      delete_all(fullname)
-    else
-      File.delete(fullname)
-    end
+def found_path(arg_name)
+  project_name = ARGV[ARGV.find_index(arg_name) + 1]
+  path = `pwd`.chomp
+  if project_name != 'run' && project_name != 'guard' && !project_name.nil? &&
+    project_name != 'port:' && project_name != 'server' && project_name != 'build'
+    path = "#{path}/#{project_name}"
   end
-  Dir.delete(dir)
+  path
 end
 
-def run(option = :browser, location = nil)
-  case option
-  when :server
-    require 'atome'
-    if location
-      `cd ./#{location}/server;rackup --server puma --port 9292  --env production`
-    else
-      `cd ./server;rackup --server puma --port 9292  --env production`
-    end
-  when :browser
-    if location
-      `cd ./#{location}/build;open index.html`
-    else
-      `cd ./build;open index.html`
-    end
-  when :osx
-    require 'webview_ruby'
-    webview = WebviewRuby::Webview.new
-    webview.set_title('atome')
-    webview.set_size(480, 360)
-    if location
-      webview.navigate("file:/#{`pwd`}/#{location}/build/index.html")
+def delete_all(dir, user_application = false)
+  Dir.foreach(dir) do |e|
+    next if %w[. ..].include? e
+
+    full_name = dir + File::Separator + e
+    if FileTest.directory?(full_name)
+      delete_all(full_name, user_application) if user_application && dir != 'application'
     else
-      webview.navigate("file:#{`pwd`.chomp}/build/index.html")
+      File.delete(full_name)
     end
-    webview.run
-  else
-    # nothing for now
   end
+  Dir.delete(dir) if user_application && dir != 'application'
+end
 
+def build_app(path, production)
+  # now run the rake task to build the needed libraries (atome, renderers, etc...)
+  app_builder_helpers = File.join(File.dirname(__FILE__), '../app_builder_helpers')
+  # now run the rake task to compile user code to javascript
+  `cd #{app_builder_helpers};rake build_user_code[#{path},#{production}]`
 end
 
-case ARGV[0]
-when 'create'
-  project_name = ARGV[1]
-  force = ARGV[2]
-  delete_all(project_name) if force == 'force'
-  Dir.mkdir project_name.to_s
+def create_application(project_name, force, production)
+  # print "directory already exist, use force to overwrite"
+  new_app_creation = false
   current_path = `pwd`.chomp
+  unless force && File.directory?(project_name)
+    new_app_creation = true
+    Dir.mkdir project_name
+    # now lets create the application identity
+    uuid = SecureRandom.uuid
+    sha = Digest::SHA256.hexdigest(uuid)
+    coded_id = sha.gsub('-', '_')
+    added_content = <<~STR
+      class Atome
+        def self.aui
+          "#{coded_id}"
+        end
+      end
+    STR
+    file_location = "#{current_path}/#{project_name}/aui.rb"
+    File.new file_location, 'w'
+    File.open(file_location, 'w') do |f|
+      f.puts added_content
+    end
+  end
+
   gem_assets_location = File.join(File.dirname(__FILE__), '../vendor/assets/')
   app_builder_helpers = File.join(File.dirname(__FILE__), '../app_builder_helpers')
   target_template_location = "#{current_path}/#{project_name}"
@@ -66,24 +72,143 @@ when 'create'
     end
   end
   # now run the rake task to build the needed libraries (atome, renderers, etc...)
-  `cd #{app_builder_helpers};rake system_builder #{current_path}/#{project_name}`
-  run(:server, project_name)
-when 'run'
-  case ARGV[1]
+  `cd #{app_builder_helpers};rake system_builder[#{current_path}/#{project_name},#{production}]`
+  if new_app_creation
+    # now adding name to the app
+    index_html = "#{current_path}/#{project_name}/build/index.html"
+    index_html_content = File.open(index_html).read
+    index_html_content = index_html_content.gsub('<title>atome</title>', "<title>#{project_name}</title>")
+    File.open(index_html, 'w') do |f|
+      f.puts index_html_content
+    end
+  end
+end
+
+def update_application(project_name, production)
+  app_builder_helpers = File.join(File.dirname(__FILE__), '../app_builder_helpers')
+  `cd #{app_builder_helpers};rake system_updater[#{project_name},#{production}]`
+end
+
+def guard_check
+  loop do
+    sleep 9
+  end
+  nil unless ARGV.include?('guard')
+end
+
+def run_application(build_target, location, port = 9292)
+  case build_target
+  when :server
+    threads = []
+    threads << Thread.new do
+      sleep 1.5
+      `open http://localhost:9292/index`
+    end
+    `cd #{location}/server;rackup --server puma --port #{port}  --env production`
+  when :browser
+    `cd #{location}/build;open index.html`
+    guard_check
+  when :native
+    # freebsd
+  when :linux
+    # freebsd
+  when :osx
+    # osx
+  when :windows
+    # windows
+  else
+    `cd #{location}/build;open index.html`
+    guard_check
+  end
+end
+
+# below we analyse the ARGV
+location = '/'
+force = nil
+production = nil
+port = 9292
+
+production = 'production' if ARGV.include?('production')
+
+force = 'force' if ARGV.include?('force')
+
+port = ARGV[ARGV.find_index('port:') + 1] if ARGV.include?('port:')
+
+platforms = %w[android browser server osx freebsd ios linux osx windows]
+# now setting build_target
+
+build_target = 'browser'
+
+platforms.each do |platform|
+  build_target = platform if ARGV.include?(platform)
+end
+
+if ARGV.include?('create')
+  project_name = ARGV[1]
+  location = "/#{project_name}"
+  create_application(project_name, force, production)
+end
+
+if ARGV.include?('build')
+  path = found_path('build')
+  build_app(path, production)
+end
+
+if ARGV.include?('update')
+  # TODO: also update index.html and all other files except the application folder
+  path = found_path('update')
+  update_application(path, production)
+end
+
+if ARGV.include?('guard')
+  Thread.new do
+    sleep 1.2
+    Dir.chdir("./#{location}") do
+      `guard`
+    end
+  end
+end
+
+if ARGV.include?('run')
+  path = if location != '/'
+           "#{`pwd`.chomp}/#{location}"
+         else
+           found_path('run')
+         end
+
+  case build_target
   when 'android'
+    # TODO: write code here
   when 'browser'
-    run(:browser)
+    run_application(:browser, path)
   when 'freebsd'
+    # TODO: write code here
   when 'ios'
+    # TODO: write code here
   when 'linux'
+    # TODO: write code here
   when 'osx'
-    run(:osx)
+    run_application(:osx, path)
   when 'server'
-    run(:server)
+    config_location = "#{path}/server/config.ru"
+    file = File.open(config_location)
+    text = file.read
+    text = text.gsub('run Unreloader', '')
+    text = text.gsub('run App.freeze.app', '')
+    text = text.gsub(/^$\n/, '')
+    text = if production == 'production'
+             "#{text}run App.freeze.app"
+           else
+             "#{text}run Unreloader"
+           end
+    File.open(config_location, 'w') do |f|
+      f.puts text
+    end
+    run_application(:server, path, port)
   when 'windows'
+    # TODO: write code here
   else
-    # type code here
+    run_application(:browser, path)
   end
-else
-  # type code here
+
 end

data/lib/atome/atome_native_extensions.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'atome/extensions/sha'
+require 'atome/extensions/ping'
+require 'atome/extensions/geolocation'

data/lib/atome/extensions/geolocation.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'geocoder'
+
+# add on for the atome method
+class Atome
+  def geolocation
+    # native version
+    public_ip = `curl https://api.ipify.org`
+    results = Geocoder.search(public_ip)
+    results.first.coordinates
+  end
+end
+

data/lib/atome/extensions/helper.rb

@@ -0,0 +1,123 @@
+def grab(val)
+  Atome.grab(val)
+end
+
+
+def read_ruby(file)
+  `
+fetch('medias/rubies/'+#{file})
+  .then(response => response.text())
+  .then(text => Opal.eval(text))
+`
+end
+
+def read_text(file)
+  `
+fetch('medias/rubies/'+#{file})
+  .then(response => response.text())
+  .then(text => console.log(text))
+`
+end
+
+
+def read(file, action=:text)
+  send("read_#{action}", file)
+end
+
+def wait(seconds)
+  seconds = seconds.to_f
+  `setTimeout(function(){ #{yield} }, #{seconds * 1000})`
+end
+
+
+def repeater(counter,proc)
+  instance_exec(counter,&proc) if proc.is_a?(Proc)
+end
+
+def repeat(delay = 1, repeat = 0, &proc)
+  # below we exec the call a first time
+  instance_exec(0,&proc) if proc.is_a?(Proc)
+  # as we exec one time above we subtract one below
+  %x{
+var  x = 1
+var intervalID = window.setInterval(function(){ Opal.Object.$repeater(x,#{proc})
+if (++x ===#{repeat} )  {
+       window.clearInterval(intervalID);
+   }}, #{delay * 1000})
+}
+
+end
+
+
+
+`
+const atome = {
+    jsSchedule: function (years, months, days, hours, minutes, seconds, proc) {
+        const now = new Date();
+        const formatedDate = new Date(years, months - 1, days, hours, minutes, seconds);
+        const diffTime = Math.abs(formatedDate - now);
+        setTimeout(function () {
+            Opal.Object.$schedule_callback(proc);
+        }, diffTime);
+    }}
+`
+
+def schedule(date, &proc)
+  date = date.to_s
+  delimiters = [",", " ", ":", "-"]
+  formated_date = date.split(Regexp.union(delimiters))
+  missing_datas = Time.now
+  missing_datas = missing_datas.to_s
+  delimiters = [",", " ", ":", "-"]
+  missing_datas_formated_date = missing_datas.split(Regexp.union(delimiters))
+
+  case formated_date.length
+  when 1
+    seconds = formated_date[0]
+    minutes = missing_datas_formated_date[4]
+    hours = missing_datas_formated_date[3]
+    days = missing_datas_formated_date[2]
+    months = missing_datas_formated_date[1]
+    years = missing_datas_formated_date[0]
+
+  when 2
+    seconds = formated_date[0]
+    minutes = formated_date[1]
+    hours = missing_datas_formated_date[3]
+    days = missing_datas_formated_date[2]
+    months = missing_datas_formated_date[1]
+    years = missing_datas_formated_date[0]
+  when 3
+    seconds = formated_date[0]
+    minutes = formated_date[1]
+    hours = formated_date[2]
+    days = missing_datas_formated_date[2]
+    months = missing_datas_formated_date[1]
+    years = missing_datas_formated_date[0]
+  when 4
+    seconds = formated_date[0]
+    minutes = formated_date[1]
+    hours = formated_date[2]
+    days = formated_date[3]
+  when 5
+    seconds = formated_date[0]
+    minutes = formated_date[1]
+    hours = formated_date[2]
+    days = formated_date[3]
+    months = formated_date[4]
+    years = missing_datas_formated_date[0]
+  else
+    years = formated_date[0]
+    months = formated_date[1]
+    days = formated_date[2]
+    hours = formated_date[3]
+    minutes = formated_date[4]
+    seconds = formated_date[5]
+  end
+  `atome.jsSchedule(#{years},#{months},#{days},#{hours},#{minutes},#{seconds},#{proc})`
+end
+
+
+def schedule_callback(proc)
+  instance_exec(&proc) if proc.is_a?(Proc)
+end

data/lib/atome/extensions/ping.rb

@@ -0,0 +1,13 @@
+def ping(address, my_proc: false)
+  # if  RUBY_ENGINE.downcase != 'opal'
+  def up?(host, my_proc)
+    check = Net::Ping::External.new(host)
+    if check.ping?
+      puts "ping respond!! "
+    end
+  end
+
+  chost = address
+  puts up?(chost, my_proc) # prints "true" if ping replies
+  # end
+end

data/lib/atome/extensions/sha.rb

@@ -0,0 +1,6 @@
+class Atome
+  def calculate_sha(string)
+    Digest::SHA256.hexdigest(string)
+  end
+end
+

data/lib/atome/extensions/utilities.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Utilities
+module Utilities
+  @atome_list = []
+  @particle_list = []
+  @renderer_list = [:html, :headless, :server]
+
+
+  def self.renderer_list(atome = nil)
+    @renderer_list
+  end
+  def self.atome_list(atome = nil)
+    # this method is used to hold all available type of atomes
+    if atome
+      instance_variable_get('@atome_list').push(atome)
+    else
+      instance_variable_get('@atome_list')
+    end
+  end
+
+  #
+  def self.particle_list(particle = nil)
+    # this method is used to hold all available type of particles
+    if particle
+      instance_variable_get('@particle_list').push(particle)
+    else
+      instance_variable_get('@particle_list')
+    end
+  end
+
+  def self.grab(params)
+    atome_found = nil
+    Universe.atomes.each do |atome|
+      atome_found = atome if atome.id == params
+    end
+    atome_found
+  end
+end