atome 0.5.7.0.3 → 0.3191

data/exe/atome

@@ -4,876 +4,214 @@
 require 'fileutils'
 require 'securerandom'
 require 'digest/sha2'
-require 'pathname'
-require 'opal'
-require 'parser'
-require 'uglifier'
-require 'rubygems'
-require 'gems'
-
-# utils
-
-def modify_and_copy_file(source_path, destination_path, destination_dir)
-
-  file_content = File.read(source_path)
-  cleaned_content = file_content.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
-  modified_code = cleaned_content.gsub(/require\s+(['"])(.*?)\1/) do |match|
-    quote = $1
-    relative_path = $2
-    if relative_path.start_with?('./')
-      relative_path_copy = "#{relative_path}"
-      relative_path_copy.slice!(0, 2)
-      destination_dir_copy = "#{destination_dir}"
-      destination_dir_copy.slice!(0, 2)
-      "require #{quote}#{relative_path_copy}#{quote}"
-    else
-      match
-    end
+# below are the methods needed for atome creation and run
 
+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
-  File.write(destination_path, modified_code)
+  path
 end
 
-def process_directories(source_dir, destination_dir)
-
-  Dir.entries(source_dir).each do |entry|
-    next if entry == '.' || entry == '..'
-
-    source_path = File.join(source_dir, entry)
-    destination_path = File.join(destination_dir, entry)
+def delete_all(dir, user_application = false)
+  Dir.foreach(dir) do |e|
+    next if %w[. ..].include? e
 
-    if File.directory?(source_path)
-      Dir.mkdir(destination_path) unless Dir.exist?(destination_path)
-      process_directories(source_path, destination_path)
-    elsif File.file?(source_path)
-      modify_and_copy_file(source_path, destination_path, destination_dir)
-    end
-  end
-end
-
-# builders
-def build_aui(destination, project_name)
-  path = "#{destination}/#{project_name}/src/utilities/"
-  FileUtils.mkdir_p(path) unless Dir.exist?(path)
-  uuid = SecureRandom.uuid
-  sha = Digest::SHA256.hexdigest(uuid)
-  coded_id = sha.gsub('-', '_')
-  aui_file = <<~STR
-    class Atome
-      def self.aui
-        "#{coded_id}"
+    full_name = dir + File::Separator + e
+    if FileTest.directory?(full_name)
+      delete_all(full_name, user_application) if user_application && dir != 'application'
+    else
+      File.delete(full_name)
+    end
+  end
+  Dir.delete(dir) if user_application && dir != 'application'
+end
+
+def build_app(path, production)
+  # current_path = `pwd`.chomp
+  # 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
+
+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
-  STR
-  File.new("#{path}aui.rb", 'w')
-  File.open("#{path}aui.rb", 'w') do |f|
-    f.puts aui_file
-  end
-  # now building opal version
-  js_directory = "#{destination}/#{project_name}/src/js"
-  opal_js = "#{js_directory}/aui.js"
-  FileUtils.mkdir_p(js_directory)
-  File.new opal_js, 'w'
-  # we add platform_specific script to the Opal framework
-  opal_content = Opal::Builder.build("#{path}aui.rb").to_s
-  File.open(opal_js, 'w') do |f|
-    f.puts opal_content
   end
 
-end
-
-def build_host_mode(destination, project_name, mode)
-  path = "#{destination}/#{project_name}/src/utilities/"
-  FileUtils.mkdir_p(path) unless Dir.exist?(path)
-  host_type = <<~STR
-    class Atome
-      def self.host
-        "#{mode}"
-      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}"
+  Dir.entries(gem_assets_location).select do |entry|
+    if File.join(entry) && !%w[. ..].include?(entry)
+      entry = "#{File.dirname(__FILE__)}/../vendor/assets/#{entry}"
+      FileUtils.cp_r entry, target_template_location
     end
-  STR
-  File.new("#{path}host_mode.rb", 'w')
-  File.open("#{path}host_mode.rb", 'w') do |f|
-    f.puts host_type
-  end
-  # now building opal version
-  js_directory = "#{destination}/#{project_name}/src/js"
-  opal_js = "#{js_directory}/host_mode.js"
-  File.new opal_js, 'w'
-  # we add platform_specific script to the Opal framework
-  opal_content = Opal::Builder.build("#{path}host_mode.rb").to_s
-  File.open(opal_js, 'w') do |f|
-    f.puts opal_content
-  end
-end
-
-# opal compilation
-def build_opal_application(_source, destination, project_name)
-  # first we need to remplace all './require ' with require  so opal can parse the path
-  Dir.mkdir("#{destination}/#{project_name}/tmp") unless Dir.exist?("#{destination}/#{project_name}/tmp")
-  unless Dir.exist?("#{destination}/#{project_name}/tmp/application")
-    Dir.mkdir("#{destination}/#{project_name}/tmp/application")
-  end
-  process_directories("#{destination}/#{project_name}/application", "#{destination}/#{project_name}/tmp/application")
-
-  opal_compiler_content = <<STR
-# frozen_string_literal: true
-
-require 'opal'
-application_js = "../../src/js/application.js"
-builder = Opal::Builder.new
-builder.append_paths("./")
-application_content = builder.build("./index.rb").to_s
-File.open(application_js, 'w') do |f|
-  f.puts application_content
-end
-STR
-
-  # we create an hidden file
-  opal_compiler = "#{destination}/#{project_name}/tmp/application/.opal_compiler.rb"
-  File.open(opal_compiler, 'w') do |f|
-    f.puts opal_compiler_content
-  end
-  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-    # code to exec with Windows
-    `cd #{destination}\\#{project_name}\\tmp\\application\\ && echo %cd% && ruby .opal_compiler.rb`
-
-  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-    # code to exec with MacOS
-    `cd #{destination}/#{project_name}/tmp/application/;pwd;ruby .opal_compiler.rb`
-
-  else
-    # code to exec with Unix/Linux
-    `cd #{destination}/#{project_name}/tmp/application/;pwd;ruby .opal_compiler.rb`
-  end
-
-end
-
-def add_to_application_folder(script_source, destination, project_name)
-  # this method is to add addition script to the application folder (useful for test per example)
-  destination_dir = "#{destination}/#{project_name}/application"
-  FileUtils.cp_r(Dir["#{script_source}/*"], destination_dir)
-end
-
-def build_opal_library(atome_source, destination, project_name, production = nil)
-
-  user_project_path = "#{destination}/#{project_name}"
-  opal_directory = "#{user_project_path}/src/js/opal"
-  opal_js = "#{opal_directory}/opal.js"
-  Dir.mkdir(opal_directory) unless File.directory?(opal_directory)
-  File.new opal_js, 'w'
-  # we add platform_specific script to the Opal framework
-  opal_content = Opal::Builder.build("#{atome_source}/lib/platform_specific/opal/opal.rb").to_s
-  File.open(opal_js, 'w') do |f|
-    f.puts opal_content
-  end
-end
-
-def create_application(source, destination, project_name)
-  project_path = "#{destination}/#{project_name}"
-  FileUtils.mkdir_p(destination) unless Dir.exist?(destination)
-  FileUtils.mkdir_p(project_path) unless Dir.exist?(project_path)
-  files_list = ['application', 'server', 'src', 'src-tauri', 'src-wasm', 'Guardfile', 'Rakefile']
-  file_to_refresh = ['application', 'server', 'src', 'src-tauri', 'Rakefile']
-  # we delete many folder to ensure they'll refreshed
-  file_to_refresh.each do |file|
-    FileUtils.rm_rf("#{destination}/#{project_name}/#{file}")
-  end
-  # we copy all folder to be refreshed
-  files_list.each do |file|
-    FileUtils.cp_r("#{source}/vendor/assets/#{file}", "#{destination}/#{project_name}/#{file}")
-  end
-  build_aui(destination, project_name)
-  # now lets add eVe now
-  # if eVe_copy
-  #   # we update eVe first
-  #   gem_spec = Gem::Specification.find_by_name('atome_eVe')
-  #   gem_path = gem_spec.gem_dir
-  #   puts "eve location : #{gem_path}"
-  #   FileUtils.cp_r(Dir["#{gem_path}/*"], source+"/lib/eVe/")
-  # end
-  # build eVe kernel
-  # build_eVe_kernel_for_opal(source, destination, project_name)
-end
-
-def update_application(source, destination, project_name)
-  project_path = "#{destination}/#{project_name}"
-  FileUtils.mkdir_p(destination) unless Dir.exist?(destination)
-  FileUtils.mkdir_p(project_path) unless Dir.exist?(project_path)
-  files_list = ['application', 'server', 'src', 'src-tauri', 'src-wasm', 'Guardfile', 'Rakefile']
-  file_to_refresh = ['application', 'server', 'src',]
-  # we delete many folder to ensure they'll refreshed
-  file_to_refresh.each do |file|
-    FileUtils.rm_rf("#{destination}/#{project_name}/#{file}")
-  end
-  # we copy all folder to be refreshed
-  files_list.each do |file|
-    FileUtils.cp_r("#{source}/vendor/assets/#{file}", "#{destination}/#{project_name}/#{file}") unless Dir.exist?(file)
-  end
-  build_aui(destination, project_name)
-end
-
-def build_opal_parser(source, destination, project_name)
-  parser_js = "#{destination}/#{project_name}/src/js/opal/opal_parser.js"
-  File.new parser_js, 'w'
-  parser_content = Opal::Builder.build("#{source}/lib/platform_specific/opal/opal_parser.rb").to_s
-  File.open(parser_js, 'w') do |f|
-    f.puts parser_content
-  end
-end
-
-def build_atome_kernel_for_opal(source, destination, project_name)
-  #  now lets build the atome kernel
-  atome_directory = "#{destination}/#{project_name}/src/js/atome"
-  kernel_js = "#{atome_directory}/kernel.js"
-  FileUtils.mkdir_p(atome_directory)
-  File.new kernel_js, 'w'
-  builder = Opal::Builder.new
-  builder.append_paths("#{source}/lib/")
-  kernel_content = builder.build("#{source}/lib/atome.rb").to_s
-  File.open(kernel_js, 'w') do |f|
-    f.puts kernel_content
   end
-end
-
-# def build_eVe_kernel_for_opal(source, destination, project_name)
-#
-#   gem_name = 'atome_eVe'
-#   # begin
-#     Gem::Specification.find_by_name(gem_name)
-#     # puts " gem 'eve' est installée."
-#     gem_spec = Gem::Specification.find_by_name(gem_name)
-#     gem_path = gem_spec.gem_dir
-#     # puts "Le chemin vers la gem '#{gem_name}' est '#{gem_path}'"
-#   # puts '-----'
-#   # puts "==> #{gem_path}/lib/eVe.rb"
-#   # rescue Gem::LoadError
-#   #   # Code à exécuter si la gemme 'eve' n'est pas installée
-#   #   puts "La gem '#{gem_name}' n'est pas installée."
-#   # end
-#   #  now lets build the atome kernel
-#   atome_directory = "#{destination}/#{project_name}/src/js/atome"
-#   kernel_js = "#{atome_directory}/eVe_kernel.js"
-#   FileUtils.mkdir_p(atome_directory)
-#   File.new kernel_js, 'w'
-#   builder = Opal::Builder.new
-#   builder.append_paths("#{source}/lib/")
-#   kernel_content = builder.build("#{gem_path}/lib/eVe.rb").to_s
-#   File.open(kernel_js, 'w') do |f|
-#     f.puts kernel_content
-#   end
-# end
-
-def build_opal_extensions(source, destination, project_name)
-  opal_directory = "#{destination}/#{project_name}/src/js/opal"
-  extensions_js = "#{opal_directory}/atome_opal_extensions.js"
-  File.new extensions_js, 'w'
-  builder = Opal::Builder.new
-  builder.append_paths("#{source}/lib/platform_specific/opal/")
-  extensions_content = builder.build("#{source}/lib/platform_specific/opal/atome_opal_extensions.rb").to_s
-  File.open(extensions_js, 'w') do |f|
-    f.puts extensions_content
-  end
-end
-
-# wasm compilation
-def wasm_common(source, destination, project_name, wasi_file, host_mode, script_source = nil)
-  # create_application(source, destination, project_name)
-  # the line below is to add addition script to the application folder (useful for test per example)
-  add_to_application_folder(script_source, destination, project_name) if script_source
-  # build host_mode
-  build_host_mode(destination, project_name, host_mode)
-  # build wasm
-  build_for_wasm(source, destination, project_name, wasi_file)
-end
-
-def wasm_initialize (source, destination, project_name, wasi_source)
-  application_location = "#{destination}/#{project_name}"
-  wasm_location = "#{application_location}/src/wasm/"
-  Dir.mkdir(wasm_location) unless Dir.exist?(wasm_location)
-
-  wasm_temp_folder = "#{application_location}/tmp"
-  Dir.mkdir(wasm_temp_folder) unless Dir.exist?(wasm_temp_folder)
-  #### IMPORTANT TO REFRESH RUBY WASM TO THE LATEST VERSION, (when ruby_browser get far too large)
-  # and UNCOMMENT the line  below : ('curl -LO ....')
-  unless File.exist?("#{wasm_temp_folder}/ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz")
-
-    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-      application_location = "#{destination}\\#{project_name}"
-      wasm_temp_folder = "#{application_location}\\tmp"
-      `cd /d #{wasm_temp_folder} && curl -LO https://github.com/ruby/ruby.wasm/releases/download/2023-11-17-a/ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz
-`
-    elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-      # code to exec with MacOS
-      # `cd #{wasm_temp_folder};curl -LO https://github.com/ruby/ruby.wasm/releases/latest/download/ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz`
-      `cd #{wasm_temp_folder};curl -LO https://github.com/ruby/ruby.wasm/releases/download/2023-11-17-a/ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz`
-      # debug :  https://github.com/ruby/ruby.wasm/releases/download/2023-11-17-a/ruby-3_2-wasm32-unknown-wasi-minimal-js-debug.tar.gz
-      # standard :     `cd #{wasm_temp_folder};curl -LO https://github.com/ruby/ruby.wasm/releases/download/2023-11-17-a/ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz`
-
-    else
-      # code to exec with Unix/Linux
-      `cd #{wasm_temp_folder};curl -LO https://github.com/ruby/ruby.wasm/releases/download/2023-11-17-a/ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz`
+  # now run the rake task to build the needed libraries (atome, renderers, etc...)
+  `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
-
-  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-    # code to exec with Windows
-    application_location = "#{destination}\\#{project_name}"
-
-    `cd /d #{wasm_temp_folder} && tar xfz ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz`
-    `move #{wasm_temp_folder}\\3_2-wasm32-unknown-wasi-full-js\\usr\\local\\bin\\ruby #{wasm_temp_folder}\\system_ruby_browser.wasm`
-    `del #{application_location}\\src\\wasm\\ruby_browser.wasm`
-  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-    # code to exec with MacOS
-    `cd #{wasm_temp_folder}; tar xfz ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz`
-    `mv #{wasm_temp_folder}/3_2-wasm32-unknown-wasi-full-js/usr/local/bin/ruby #{wasm_temp_folder}/system_ruby_browser.wasm`
-    `rm -f #{application_location}/src/wasm/ruby_browser.wasm`
-  else
-    # code to exec with Unix/Linux
-    `cd #{wasm_temp_folder}; tar xfz ruby-3_2-wasm32-unknown-wasi-full-js.tar.gz`
-    `mv #{wasm_temp_folder}/3_2-wasm32-unknown-wasi-full-js/usr/local/bin/ruby #{wasm_temp_folder}/system_ruby_browser.wasm`
-    `rm -f #{application_location}/src/wasm/ruby_browser.wasm`
-  end
-
-  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-    # code to exec with Windows
-    cmd = <<~STRDELIM
-      "#{application_location}\\src-wasm\\wasm\\#{wasi_source}" pack "#{wasm_temp_folder}\\system_ruby_browser.wasm"
-          -mapdir usr::"#{wasm_temp_folder}\\3_2-wasm32-unknown-wasi-full-js\\usr"
-          -mapdir lib::"#{source}\\lib\\"
-          -mapdir \::"#{application_location}\\application\\"
-          -mapdir utilities::"#{application_location}\\src\\utilities\\"
-          -o "#{application_location}\\src\\wasm\\ruby_browser.wasm"
-    STRDELIM
-  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-    # code to exec with MacOS
-    cmd = <<~STRDELIM
-      #{application_location}/src-wasm/wasm/#{wasi_source} pack #{wasm_temp_folder}/system_ruby_browser.wasm
-      --mapdir usr::#{wasm_temp_folder}/3_2-wasm32-unknown-wasi-full-js/usr
-      --mapdir lib::#{source}/lib/
-      --mapdir /::#{application_location}/application/
-      --mapdir utilities::#{application_location}/src/utilities/
-      -o #{application_location}/src/wasm/ruby_browser.wasm
-    STRDELIM
-  else
-    # code to exec with Unix/Linux
-    cmd = <<~STRDELIM
-      #{application_location}/src-wasm/wasm/#{wasi_source} pack #{wasm_temp_folder}/system_ruby_browser.wasm
-      --mapdir usr::#{wasm_temp_folder}/3_2-wasm32-unknown-wasi-full-js/usr
-      --mapdir lib::#{source}/lib/
-      --mapdir /::#{application_location}/application/
-      --mapdir utilities::#{application_location}/src/utilities/
-      -o #{application_location}/src/wasm/ruby_browser.wasm
-    STRDELIM
-  end
-
-  cleaned_cmd = cmd.lines.reject { |line| line.start_with?('#') }.join
-  command = cleaned_cmd.chomp.gsub("\n", ' ')
-  system(command)
-end
-
-def build_for_wasm(source, destination, project_name, wasi_file)
-  wasm_initialize(source, destination, project_name, wasi_file)
 end
 
-def build_for_osx(destination, mode = :dev)
-  # dev or build
-  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-    # code to exec with Windows
-    `cd /d #{destination} && cargo tauri #{mode}`
-  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-    # code to exec with MacOS
-    `cd #{destination};cargo tauri #{mode}`
-  else
-    # code to exec with Unix/Linux
-    `cd #{destination};cargo tauri #{mode}`
-  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 init_server(destination, project_name, port, prod, ru_file)
-
-  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-    # code to exec with Windows
-    File.open("#{destination}\\#{project_name}\\server\\config.ru", "w") do |f|
-      f.write(ru_file)
-    end
-    # `cd /d #{destination}\\#{project_name}\\server && puma --port #{port} #{prod}`
-    # system("start cmd /c cd /d #{destination}\\#{project_name}\\server && puma --port #{port} #{prod}")
-    system("cd /d \"#{destination}\\#{project_name}\\server\" && puma --port #{port} #{prod}")
-
-  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-    # code to exec with MacOS
-    File.open("#{destination}/#{project_name}/server/config.ru", "w") do |f|
-      f.write(ru_file)
-    end
-    # `cd #{destination}/#{project_name}/server;puma --port #{port} #{prod}`
-    system("cd #{destination}/#{project_name}/server && puma --port #{port} #{prod}")
-
-  else
-    # code to exec with Unix/Linux
-    File.open("#{destination}/#{project_name}/server/config.ru", "w") do |f|
-      f.write(ru_file)
+def guard_check
+  if ARGV.include?('guard')
+    loop do
+      sleep 9
     end
-    # `cd #{destination}/#{project_name}/server;puma --port #{port} #{prod}`
-    system("cd #{destination}/#{project_name}/server && puma --port #{port} #{prod}")
   end
 end
 
-def build_for_opal_server(destination, project_name, port, production, run_server = true)
-  if production
-    prod = '--env production'
-    ru_file = <<STR
-require 'roda'
-require './atome_server.rb'
-run App.app.freeze
-STR
+def run_application(build_target, location, port = 9292)
+  case build_target
+  when :server
+    # require 'atome'
+    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
-    ru_file = <<STR
-require 'roda'
-require 'rack/unreloader'
-Unreloader = Rack::Unreloader.new(subclasses: %w[Roda]) { App }
-Unreloader.require './atome_server.rb'
-run Unreloader
-require './atome_server.rb'
-STR
-  end
-  if run_server ==true
-    init_server(destination, project_name, port, prod, ru_file)
+    `cd #{location}/build;open index.html`
+    guard_check
   end
 
 end
 
-def build_for_wasm_server(destination, project_name, port, production, run_server = true)
-  if production
-    prod = '--env production'
-    ru_file = <<STR
-require 'roda'
-require './atome_server_wasm.rb'
-run App.app.freeze
-STR
-  else
-    ru_file = <<STR
-require 'roda'
-require 'rack/unreloader'
-Unreloader = Rack::Unreloader.new(subclasses: %w[Roda]) { App }
-Unreloader.require './atome_server_wasm.rb'
-run Unreloader
-require './atome_server.rb'
-STR
-  end
-  if run_server ==true
-    init_server(destination, project_name, port, prod, ru_file)
-  end
-  # if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-  #   # code to exec with Windows
-  #   File.open("#{destination}\\#{project_name}\\server\\config.ru", "w") do |f|
-  #     f.write(ru_file)
-  #   end
-  #   `cd /d #{destination}\\#{project_name}\\server && puma --port #{port} #{prod}`
-  # elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-  #   # code to exec with MacOS
-  #   File.open("#{destination}/#{project_name}/server/config.ru", "w") do |f|
-  #     f.write(ru_file)
-  #   end
-  #   `cd #{destination}/#{project_name}/server;puma --port #{port} #{prod}`
-  # else
-  #   # code to exec with Unix/Linux
-  #   File.open("#{destination}/#{project_name}/server/config.ru", "w") do |f|
-  #     f.write(ru_file)
-  #   end
-  #   `cd #{destination}/#{project_name}/server;puma --port #{port} #{prod}`
-  # end
+# below we analyse the ARGV
+location = '/'
+force = nil
+production = nil
+port = 9292
 
-end
+production = 'production' if ARGV.include?('production')
 
-# utils
-def ensure_rb_extension(filename)
-  filename.end_with?('.rb') ? filename : "#{filename}.rb"
-end
+force = 'force' if ARGV.include?('force')
 
-def find_requires(file)
-  requires = []
-  File.foreach(file) do |line|
-    trimmed_line = line.strip
-    if trimmed_line.start_with?('require ') || trimmed_line.start_with?('require_relative ')
-      match = trimmed_line.match(/['"]([^'"]+)['"]/)
-      if match
-        path = match[1].end_with?('.rb') ? match[1][0...-3] : match[1]
-        requires << path
-      end
-    end
-  end
-  requires
-end
+port = ARGV[ARGV.find_index('port:') + 1] if ARGV.include?('port:')
 
-def copy_file(source, destination)
-  return if source == 'server.rb'
+platforms = %w[android browser server osx freebsd ios linux osx windows]
+# now setting build_target
 
-  FileUtils.mkdir_p(File.dirname(destination))
-  FileUtils.cp(source, destination)
-end
+build_target = 'browser'
 
-def copy_with_requires(source, destination, base_folder)
-  destination_file = File.join(destination, source.sub(base_folder + '/', ''))
-  copy_file(source, destination_file)
-  find_requires(source).each do |relative_path|
-    required_file = File.join(base_folder, "#{relative_path}.rb")
-    copy_with_requires(required_file, destination, base_folder) if File.exist?(required_file)
-  end
+platforms.each do |platform|
+  build_target = platform if ARGV.include?(platform)
 end
 
-# below we analyse the ARGV
-location = if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-             # code to exec with Windows
-             '\\'
-           elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-             # code to exec with MacOS
-             '/'
-           else
-             # code to exec with Unix/Linux
-             '/'
-           end
-
-project_name = ARGV[1]
-
-if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-  # code to exec with Windows
-  destination = `cd`.chomp
-  wasi_file = 'wasi-vfs.exe'
-
-elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-  # code to exec with MacOS
-  destination = `pwd`.chomp
-  wasi_file = 'wasi-vfs-osx_arm' # default to osx arm
-else
-  # code to exec with Unix/Linux
-  destination = `pwd`.chomp
-  wasi_file = 'wasi-vfs-unix'
+if ARGV.include?('create')
+  project_name = ARGV[1]
+  location = "/#{project_name}"
+  create_application(project_name, force, production)
 end
 
-source = Pathname(__FILE__).parent.parent.to_s
-
-# TODO : get wasi params from ARG to allow compile on windows / Unix
-if ARGV.include?('create')
-  create_application(source, destination, project_name)
-  # create_application(source, destination, project_name, production)
-  # 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)
+if ARGV.include?('build')
+  path = found_path('build')
+  build_app(path, production)
 end
 
 if ARGV.include?('update')
-
-  gem_name = 'atome'
-  local_gem_spec = Gem::Specification.find_by_name(gem_name) rescue nil
-  if local_gem_spec.nil?
-    puts " #{gem_name} gem  is not install will install from distant server"
-    system("gem update #{gem_name}")
-  else
-    available_versions = Gem::Specification.find_all_by_name(gem_name).map(&:version)
-
-    latest_version = available_versions.max
-
-    if latest_version > local_gem_spec.version
-      puts "update availlable: #{local_gem_spec.version} -> #{latest_version}"
-      system("gem update #{gem_name}")
-    else
-      puts "No update necessary '#{gem_name}'. current version : #{local_gem_spec.version}"
-    end
-  end
-
-
   # TODO: also update index.html and all other files except the application folder
-  # 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/molecules src/js/third_parties
-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)
-      end
-      source_item = "#{source}/vendor/assets/#{item}"
-      FileUtils.cp_r(source_item, item)
-    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)
-
-    ########################
-
-    # unless Dir.exist?("#{destination}/vendor")
-    #   Dir.mkdir("#{destination}/vendor")
-    # end
-
-    #######################
-
-    puts "your application is up to date"
-  end
-
-  # now we get the version of the atome gem
-  gem_name = 'atome'
-  local_gem_spec = Gem::Specification.find_by_name(gem_name) rescue nil
-  latest_version=local_gem_spec.version
-  puts "#{gem_name} #{latest_version} is now installed "
-
+  path = found_path('update')
+  update_application(path, production)
 end
 
-current_path = Pathname.new(Dir.pwd)
-project_name = current_path.basename.to_s
-destination = current_path.parent.to_s
-
-if ARGV.include?('run')
-  case ARGV[1]
-  when 'opal'
-
-    guard_content = <<STR
-guard 'rake', first_match: true, :task => 'build_opal' do
-  watch(%r{^server.+\.rb})
-  watch(%r{^application.+\.rb})
-end
-STR
-
-    File.open("./#{location}/Guardfile", "w") do |f|
-      f.write(guard_content)
-    end
-    puts 'guarding'
+if ARGV.include?('guard')
+  Thread.new do
+    sleep 1.2
     Dir.chdir("./#{location}") do
       `guard`
     end
-  when 'wasm' # osx wasi
-    guard_content = <<STR
-guard 'rake', first_match: true, :task => 'build_wasm' do
-  watch(%r{^server.+\.rb})
-  watch(%r{^application.+\.rb})
-end
-STR
-
-    File.open("./#{location}/Guardfile", "w") do |f|
-      f.write(guard_content)
-    end
-    puts 'guarding'
-    Dir.chdir("./#{location}") do
-      `guard`
-    end
-  when 'server'
-    guard_content = <<STR
-guard 'rake', first_match: true, :task => 'build_server' do
-  watch(%r{^server.+\.rb})
-  watch(%r{^application.+\.rb})
+  end
 end
 
-STR
+if ARGV.include?('run')
+  path = if location != '/'
+           "#{`pwd`.chomp}/#{location}"
+         else
+           found_path('run')
+         end
 
-    File.open("./#{location}/Guardfile", "w") do |f|
-      f.write(guard_content)
-    end
-    puts 'guarding'
-    threads = []
-    Dir.chdir("./#{location}") do
-      threads << Thread.new do
-        `guard`
-      end
-    end
-  when 'osx'
+  case build_target
   when 'android'
-    # to be filled
+    # TODO: write code here
+  when 'browser'
+    run_application(:browser, path)
+  when 'freebsd'
+    # TODO: write code here
   when 'ios'
-    # to be filled
-  when 'windows'
-    # to be filled
+    # TODO: write code here
   when 'linux'
-    # to be filled
-  when 'freebsd'
-    # to be filled
-  end
-
-end
-
-if ARGV.include?('sparkle')
-  temp_dir = if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-               'C:\Windows\Temp'
-               # code to exec with Windows
-             elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-               '/tmp'
-               # code to exec with MacOS
-             else
-               '/tmp'
-               # code to exec with Unix/Linux
-             end
-
-  `cd #{temp_dir}; atome create atome_app` unless Dir.exist?("#{temp_dir}/atome_app")
-  # search for server file
-  if File.exist?('server.rb')
-    file_content = File.read('server.rb')
-    File.write("#{temp_dir}/atome_app/server/atome_server.rb", file_content)
-    base_folder = File.dirname(project_name)
-    copy_with_requires('server.rb', "#{temp_dir}/atome_app/server", base_folder)
-  end
-  project_name = ARGV[1]
-  if project_name.nil? || project_name == 'opal' || project_name == 'wasm' || project_name == 'server'
-    project_name = 'index.rb'
-  end
-  project_name = ensure_rb_extension(project_name)
-  base_folder = File.dirname(project_name)
-  copy_with_requires(project_name, "#{temp_dir}/atome_app/application", base_folder)
-
-  if ARGV.include?('opal')
-    `cd #{temp_dir}/atome_app;atome run opal`
-
-  elsif ARGV.include?('wasm')
-    `cd #{temp_dir}/atome_app;atome run wasm`
-
-  elsif ARGV.include?('server')
-    `cd #{temp_dir}/atome_app;atome run server`
-  else
-    `cd #{temp_dir}/atome_app;atome run opal`
-  end
-else
-  if ARGV.include?('opal')
-    puts 'building Opal'
-
-    build_opal_application(nil, destination, project_name)
-    # build host_mode
-    build_host_mode(destination, project_name, 'web-opal')
-    # build Opal extensions
-    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-      # code to exec for Windows
-      `start "" "#{destination}\\#{project_name}\\src\\index_opal.html"`
-    elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-      # code to exec for MacOS
-      `open #{destination}/#{project_name}/src/index_opal.html`
-    else
-      # code to exec for Unix/Linux
-      `open #{destination}/#{project_name}/src/index_opal.html`
-    end
-
-    puts "opal ready!"
-  end
-
-  if ARGV.include?('wasm')
-    puts 'building Ruby wasm'
-    wasi_file = 'wasi-vfs-osx_arm'
-    wasm_common(source, destination, project_name, wasi_file, :pure_wasi)
-
-    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-      # code to exec for Windows
-      `start "" "#{destination}\\#{project_name}\\src\\index_wasm.html"`
-    elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-      # code to exec for MacOS
-      `open #{destination}/#{project_name}/src/index_wasm.html`
-    else
-      # code to exec for Unix/Linux
-      `open #{destination}/#{project_name}/src/index_wasm.html`
-    end
-
-  end
-
-  if ARGV.include?('server')
-    puts 'building Server'
-    build_opal_application(nil, destination, project_name)
-    build_host_mode(destination, project_name, 'web-opal')
-    threads = []
-    threads << Thread.new do
-      # sleep 1
-      # if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-      #   # code to exec with Windows
-      #   `start "" "#{destination}\\#{project_name}\\src\\index_server.html`
-      # 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`
-      # end
-    end
-    threads << Thread.new do
-      build_for_opal_server(destination, project_name, 9292, false)
-    end
-
-    threads.each(&:join)
-
-  end
-
-  if ARGV.include?('wasm_server')
-    puts 'building Server'
-    build_opal_application(nil, destination, project_name)
-    build_host_mode(destination, project_name, 'web-opal')
-    threads = []
-    # threads << Thread.new do
-    #   # sleep 1
-    #   # if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-    #   #   # code to exec with Windows
-    #   #   `start "" "#{destination}\\#{project_name}\\src\\index_server.html`
-    #   # 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`
-    #   # end
-    # end
-    threads << Thread.new do
-      build_for_wasm_server(destination, project_name, 9292, false)
-    end
-    threads.each(&:join)
-    puts 'wasm server is running'
-  end
-
-  if ARGV.include?('server_refresh')
-    puts 're building Server'
-    build_opal_application(nil, destination, project_name)
-    timestamp = Time.now.strftime("%Y%m%d%H%M%S")
-
-    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-      # code to exec with Windows
-      # `start #{destination}\\#{project_name}\\src\\index_server.html`
-      `start   http://localhost:9292?date=#{timestamp}`
-    elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-      # code to exec with MacOS
-      `open http://localhost:9292?date=#{timestamp}`
-    else
-      # code to exec with Unix/Linux
-      `open http://localhost:9292?date=#{timestamp}`
+    # TODO: write code here
+  when 'osx'
+    run_application(:osx, path)
+  when '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
+    run_application(:browser, path)
   end
 
-  if ARGV.include?('osx')
-    puts 'building osx'
-    wasi_file = 'wasi-vfs-osx_arm'
-    wasm_common(source, destination, project_name, wasi_file, :tauri)
-    build_for_osx(destination)
-  end
-
-  puts 'building Android' if ARGV.include?('android')
-  puts 'building iOS' if ARGV.include?('ios')
-  puts 'building Windows' if ARGV.include?('windows')
-  puts 'building Linux' if ARGV.include?('linux')
-  puts 'building Freebsd' if ARGV.include?('freebsd')
-
-end
+end