atome 0.5.4.1.9 → 0.5.5.6.4

data/exe/atome

@@ -4,206 +4,339 @@
 require 'fileutils'
 require 'securerandom'
 require 'digest/sha2'
-# below are the methods needed for atome creation and run
-def test_path(project_name, arg_name, path)
-  if project_name != 'run' && project_name != 'guard' && !project_name.nil? &&
-     project_name != 'port:' && project_name != 'server' && project_name != 'build'
-    # the line below remove the optional parameters from the project name
-    project_name = project_name.sub(ARGV[ARGV.find_index(arg_name) + 1], '')
-    "#{path}/#{project_name}"
-  end
-  path
-end
+require 'pathname'
+require 'opal'
+require 'parser'
+require 'uglifier'
+
+# 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
 
-def found_path(arg_name)
-  project_name = ARGV[ARGV.find_index(arg_name) + 1]
-  path = `pwd`.chomp
-  if ARGV[ARGV.find_index(arg_name) + 1] == 'production'
-    app_builder_helpers = File.join(File.dirname(__FILE__), '../app_builder_helpers')
-    `cd #{app_builder_helpers};rake minimizer[#{path}]`
   end
-  path = `pwd`.chomp
-  test_path(project_name, arg_name, path)
+  File.write(destination_path, modified_code)
 end
 
-def delete_all(dir, user_application = nil)
-  Dir.foreach(dir) do |e|
-    next if %w[. ..].include? e
+def process_directories(source_dir, destination_dir)
 
-    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)
+  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)
+
+    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
-  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
-
-def content_to_add(coded_id)
-  <<~STR
+# 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}"
       end
     end
   STR
-end
-
-def app_creation(content_to_add, current_path, project_name)
-  added_content = content_to_add
-  file_location = "#{current_path}/#{project_name}/aui.rb"
-  File.new file_location, 'w'
-  File.open(file_location, 'w') do |f|
-    f.puts added_content
+  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"
+  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 test_app_creation(project_name, current_path, force)
-  new_app_creation = false
-  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('-', '_')
-    app_creation(content_to_add(coded_id), current_path, project_name)
+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
+    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
-  new_app_creation
 end
 
-def build_atome_resources(current_path, project_name, production)
-  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
+# 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
-  # 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}]`
+  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
 
-def create_application(project_name, force, production)
-  # print "directory already exist, use force to overwrite"
-  current_path = `pwd`.chomp
-  new_app_creation = test_app_creation(project_name, current_path, force)
-  build_atome_resources(current_path, project_name, production)
-  return unless new_app_creation
-
-  # now adding name to the app
-  index_html = "#{current_path}/#{project_name}/src/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
+  # 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
+  `cd #{destination}/#{project_name}/tmp/application/;pwd;ruby .opal_compiler.rb`
 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}]`
+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 guard_check
-  loop do
-    sleep 1
+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
-  nil unless ARGV.include?('guard')
 end
 
-def browser_case(location)
-  `cd #{location}/src;open index.html`
-  # `echo jello`
-  # guard_check
+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}") unless Dir.exist?(file)
+  end
+  build_aui(destination, project_name)
 end
 
-def osx_case(location)
-  `cd #{location};cargo tauri dev`
+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 compile_case(location)
-  `cd #{location}/src`
-  guard_check
-end
+def build_opal_parser(source, destination, project_name)
 
-def server_case(port, location)
-  threads = []
-  threads << Thread.new do
-    sleep 1.5
-    `open http://localhost:9292/index`
+  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
-  `cd #{location}/server;rackup --server puma --port #{port}  --env production`
 end
 
-def run_case(build_target, location, port)
-  case build_target
-  when :server
-    server_case(port, location)
-  when :browser
-    browser_case(location)
-  when :osx
-    osx_case(location)
-  when :compile
-    compile_case(location)
-  when :native
-    # freebsd
-  else
-    guard_check
+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"
+  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 run_application(build_target, location, port = 9292)
-  build_app(location, nil)
-  run_case(build_target, location, port)
+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
 
-# below we analyse the ARGV
-location = '/'
-force = nil
-production = nil
-port = 9292
+# 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
 
-production = 'production' if ARGV.include?('production')
+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")
+    # `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`
+  end
+  `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`
+  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
+  cleaned_cmd = cmd.lines.reject { |line| line.start_with?('#') }.join
+  command = cleaned_cmd.chomp.gsub("\n", ' ')
+  system(command)
+end
 
-force = 'force' if ARGV.include?('force')
+def guard_check
+  loop do
+    sleep 1
+  end
+  nil unless ARGV.include?('guard')
+end
 
-port = ARGV[ARGV.find_index('port:') + 1] if ARGV.include?('port:')
+def build_for_wasm(source, destination, project_name, wasi_file)
+  wasm_initialize(source, destination, project_name, wasi_file)
+end
 
-platforms = %w[android browser server osx freebsd ios linux osx windows]
-# now setting build_target
+def build_for_osx(destination, mode = :dev)
+  # dev or build
 
-build_target = 'browser'
+  `cd #{destination};cargo tauri #{mode}`
 
-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)
+def build_for_server(destination, project_name, port, production)
+  prod = '--env production' if production
+  `cd #{destination}/#{project_name}/server;puma --port #{port} #{prod}`
 end
 
-if ARGV.include?('build')
-  path = found_path('build')
-  build_app(path, production)
+# def run_application(build_target, location, port = 9292, production = false)
+#   build_app(location, nil)
+#   run_case(build_target, location, port, production)
+# end
+
+# below we analyse the ARGV
+location = '/'
+project_name = ARGV[1]
+destination = `pwd`.chomp
+source = Pathname(__FILE__).parent.parent.to_s
+
+wasi_file = 'wasi-vfs-osx_arm' # default to osx arm
+# 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)
+  wasm_common(source, destination, project_name, wasi_file, :universal)
+  # 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 Opal extensions
+  build_opal_extensions(source, destination, project_name)
+  # build application
+  build_opal_application(source, destination, project_name)
 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)
+  # first we delete everything but application
+  folders_to_keep = ['application']
+  Dir.foreach(destination) do |item|
+    item_path = File.join(destination, item)
+    if File.directory?(item_path) && !folders_to_keep.include?(item)
+      FileUtils.rm_rf(item_path) unless item == '.' || item == '..'
+    elsif File.file?(item_path)
+      File.delete(item_path)
+    end
+  end
+  # now we update
+  puts "#{source}/vendor/assets"
+
+  update_source = "#{source}/vendor/assets"
+
+  Dir.glob("#{update_source}/*").each do |item|
+    target = File.join(destination, File.basename(item))
+    FileUtils.cp_r(item, target) unless File.exist?(target)
+  end
 end
 
 if ARGV.include?('guard')
@@ -215,78 +348,45 @@ if ARGV.include?('guard')
   end
 end
 
-def set_atome_mode(location, mode)
-  mode_file = "#{location}/src/utilities/mode.rb"
-  file_found = File.open(mode_file)
-  atome_mode=<<~STR 
-    $host = :#{mode}
-  STR
-  File.open(file_found, 'w') do |f|
-    f.puts atome_mode
-  end
-end
-
 if ARGV.include?('run')
-  path = if location != '/'
-           "#{`pwd`.chomp}/#{location}"
-         else
-           found_path('run')
-         end
-  demo_location = "#{path}/src/medias/rubies"
-
-  filenames = Dir.glob(demo_location+'/examples/*.rb')
-  demos_list_content=[]
-  filenames.each do |path|
-    filename= File.basename(path)
-    demos_list_content << filename
-  end
-  demos_list_file = "#{demo_location}/demos_list.rb"
-  File.open(demos_list_file, 'w') do |f|
-    # f.puts "class Atome_demo\n  def demos_list\n    #{demos_list_content}\n  end\nend"
-    f.puts "def demos_list\n  #{demos_list_content}\nend"
-  end
-
-
-
-  case build_target
-  when 'android'
-    set_atome_mode(path,'tauri')
-    # TODO: write code here
-  when 'browser'
-    set_atome_mode(path,'browser')
-    run_application(:browser, path)
-  when 'freebsd'
-    set_atome_mode(path,'native')
-    # TODO: write code here
-  when 'ios'
-    set_atome_mode(path,'tauri')
-    # TODO: write code here
-  when 'linux'
-    # TODO: write code here
-  when 'osx'
-    set_atome_mode(path,'tauri')
-    run_application(:osx, path)
+  current_path = `pwd`.chomp
+  segments = current_path.split("/")
+  project_name = segments.last
+  destination = segments[0...-1].join("/")
+  case ARGV[1]
+  when 'opal'
+    build_opal_application(nil, destination, project_name)
+    `open #{destination}/#{project_name}/src/index_opal.html`
+  when 'wasm' # osx wasi
+    wasi_file = 'wasi-vfs-osx_arm'
+    wasm_common(source, destination, project_name, wasi_file, :pure_wasi)
+    `open #{current_path}/src/index.html`
   when 'server'
-    set_atome_mode(path,'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
+    build_opal_application(nil, destination, project_name)
+    threads = []
+    threads << Thread.new do
+      sleep 1
+      `open http://localhost:9292`
     end
-    run_application(:server, path, port)
+    build_for_server(destination, project_name, 9292, :production)
+  when 'osx'
+    wasi_file = 'wasi-vfs-osx_arm'
+    wasm_common(source, destination, project_name, wasi_file, :tauri)
+    build_for_osx(destination)
+  when 'android'
+    # to be filled
+  when 'ios'
+    # to be filled
   when 'windows'
-    # TODO: write code here
+    # to be filled
+  when 'linux'
+    # to be filled
+  when 'freebsd'
+    # to be filled
   else
-    run_application(:browser, path)
+    wasi_file = 'wasi-vfs-osx_arm'
+    wasm_common(source, destination, project_name, wasi_file, 'pure_wasm')
+    `open #{current_path}/src/index.html`
   end
 
 end