atome 0.5.3.8.8 → 0.5.4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e15b6625b3ba6dd5801418dd7dab9f9d0670dedb65e3ea8caa03df984f29541
-  data.tar.gz: 5a23055c7535a94ebe0c29b4dd226477b99564aa73a7f2640c533447bf24f52e
+  metadata.gz: 1de05964aef532fdea97ad87df059c4c8d1680b95c9ff3e4f584bcd497f759d9
+  data.tar.gz: 8ecfcf60c08122af0b74997d779a70e37826668c64abe1b9e557fafa2a60e8d5
 SHA512:
-  metadata.gz: ca47d04143b5d3cdec3120da89f863f3edaf84cbebee58fc257a8d12c7f1c2d699752ba6cc9e98e080cb10fbebe8900c788bd1c698705a59c7c0dfaa891073db
-  data.tar.gz: f1757fb74688cddb937f1a40790dd33ca121485a2446e2a5236f8de6ae9b302726b71521d2decd455e3cfca9613e37600075e91f3e96cf0777da3b5d67b4cb88
+  metadata.gz: b0ce2a3feae40b1a21f509699b25857ecbf8d3e3a0f6faa40a673b67ed1c592cb8a4676570e0e23681d83c098c045e48267ab1d3b04dc02b259799c16d79206b
+  data.tar.gz: 3c828d6324954e125c17254cdf5376bdabfde5f4b155ee8c0c15eba9d8d10bdc1a6187176606b3f3207b53e2b927b67046fe496e91a760e2f3b2c336f3e1b666

data/Rakefile

@@ -11,48 +11,83 @@ end
 
 task default: :test
 
-task :re_build do
+task :test_build do
   FileUtils.copy_entry('vendor/assets/src/js/', 'test/test_app/src/js/')
   FileUtils.copy_entry('vendor/assets/src/css/', 'test/test_app/src/css/')
   FileUtils.copy_entry('vendor/assets/src/medias/', 'test/test_app/src/medias/')
-  `gem cleanup atome;yes | gem uninstall atome;gem build atome.gemspec;gem install atome --local`
+
+  `rake build`
+  `cd pkg; gem install atome --local`
   `cd test/test_app;atome update`
+  `cd test/test_app;atome refresh`
   puts 'solution re-build!'
-  # `cd test/test_app;atome update;atome run`
+
 end
 
-task :run_browser do
+task :test_browser do
   FileUtils.copy_entry('vendor/assets/src/js/', 'test/test_app/src/js/')
   FileUtils.copy_entry('vendor/assets/src/css/', 'test/test_app/src/css/')
   FileUtils.copy_entry('vendor/assets/src/medias/', 'test/test_app/src/medias/')
-  `gem cleanup atome;yes | gem uninstall atome;gem build atome.gemspec;gem install atome --local`
   `cd test/test_app;atome update;atome run compile`
+  `open test/test_app/src/index.html`
   puts 'atome browser is running'
 end
 
+task :test_build_browser do
+  FileUtils.copy_entry('vendor/assets/src/js/', 'test/test_app/src/js/')
+  FileUtils.copy_entry('vendor/assets/src/css/', 'test/test_app/src/css/')
+  FileUtils.copy_entry('vendor/assets/src/medias/', 'test/test_app/src/medias/')
 
-task :test_server do
+  `rake build`
+  `cd pkg; gem install atome --local`
+  `cd test/test_app;atome update`
+  `cd test/test_app;atome refresh`
+  `cd test/test_app;atome update;atome run browser guard `
+  # `open test/test_app/src/index.html`
+  puts 'atome browser is running'
+end
+
+task :test_build_osx do
   FileUtils.copy_entry('vendor/assets/src/js/', 'test/test_app/src/js/')
   FileUtils.copy_entry('vendor/assets/src/css/', 'test/test_app/src/css/')
   FileUtils.copy_entry('vendor/assets/src/medias/', 'test/test_app/src/medias/')
-  `gem cleanup atome;yes | gem uninstall atome ;gem build atome.gemspec;gem install atome --local`
-  `cd test/test_app;atome update;atome run server`
+
+  `rake build`
+  `cd pkg; gem install atome --local`
+  `cd test/test_app;atome update`
+  `cd test/test_app;atome refresh`
+  `cd test/test_app;atome update;atome run osx guard`
+  # `cd test/test_app;atome run osx guard`
+  puts 'atome osx is running'
+end
+
+task :cleanup do
+  `gem cleanup atome;yes | gem uninstall atome;cd pkg`
 end
 
 
-task :run_server do
-  `cd test/test_app;atome run server guard`
+task :test_server do
+  FileUtils.copy_entry('vendor/assets/src/js/', 'test/test_app/src/js/')
+  FileUtils.copy_entry('vendor/assets/src/css/', 'test/test_app/src/css/')
+  FileUtils.copy_entry('vendor/assets/src/medias/', 'test/test_app/src/medias/')
+  `gem cleanup atome;yes | gem uninstall atome ;gem build atome.gemspec;cd pkg; gem install atome --local`
+  `cd test/test_app;atome update;atome run server guard`
 end
 
+
+# task :run_server do
+#   `cd test/test_app;atome run server guard`
+# end
+
 task :refresh do
   FileUtils.copy_entry('vendor/assets/src/medias/rubies/examples/', 'test/test_app/src/medias/rubies/examples/')
   `cd test/test_app;atome build`
   puts "refreshed!"
 end
 
-task :open_browser do
-`open http://127.0.0.1:1430/`
-end
+# task :open_server do
+# `open http://127.0.0.1:1430/`
+# end
 
 task :run_example_server do
   FileUtils.copy_entry('vendor/assets/src/medias/rubies/examples/', 'test/test_app/src/medias/rubies/examples/')
@@ -60,11 +95,11 @@ task :run_example_server do
 end
 
 
-task :taurification do
-  `cd test/test_app;cargo tauri dev`
-end
+# task :taurification do
+#   `cd test/test_app;cargo tauri dev`
+# end
 
-task :osx do
+task :test_osx do
   `cd test/test_app;atome run osx guard`
 end
 

data/app_builder_helpers/Rakefile

@@ -108,14 +108,29 @@ def build_user_code(user_project_path, source_code)
   application_js = "#{user_project_path}/src/js/application.js"
   builder = Opal::Builder.new
   builder.append_paths("#{user_project_path}/")
-  application_content = builder.build(source_code).to_s
 
+ builder.build("#{source_code}/src/utilities/mode.rb").to_s
+
+  # aui = builder.build("#{source_code}/aui.rb").to_s
+  application_content = builder.build("#{source_code}/application/index.rb").to_s
+
+  # full_app=aui+"\n"+system_infos+"\n"+application_content
   File.open(application_js, 'w') do |f|
     f.puts application_content
   end
   # minimize_application(user_project_path)
 end
 
+def build_system_infos(user_project_path, source_code)
+  system_infos_js = "#{user_project_path}/src/js/infos.js"
+      builder = Opal::Builder.new
+  builder.append_paths("#{user_project_path}/")
+  system_infos = builder.build("#{source_code}/src/utilities/mode.rb").to_s
+  File.open(system_infos_js, 'w') do |f|
+    f.puts system_infos
+  end
+end
+
 def minimize_aui(user_project_path)
   aui_js = "#{user_project_path}/src/js/aui.js"
   aui_content = File.open(aui_js).read
@@ -220,15 +235,17 @@ end
 
 task :build_user_code, :user_project_path, :production do |_t, args|
   user_project_path = args[:user_project_path]
-  source_code = "#{user_project_path}/application/index.rb"
+  source_code = "#{user_project_path}"
+  build_system_infos(user_project_path, source_code)
   build_user_code(user_project_path, source_code)
 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'
+  source_code = '../vendor/assets'
   build_common_libraries(user_project_path, production)
+  build_system_infos(user_project_path, source_code)
   build_user_code(user_project_path, source_code)
 
   # TODO: catch and message to user when when there's no force and folder already exist

data/exe/atome

@@ -123,7 +123,7 @@ def guard_check
 end
 
 def browser_case(location)
-  # `cd #{location}/src;open index.html`
+  `cd #{location}/src;open index.html`
   # `echo jello`
   # guard_check
 end
@@ -215,27 +215,59 @@ 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)
   when 'server'
+    set_atome_mode(path,'server')
     config_location = "#{path}/server/config.ru"
     file = File.open(config_location)
     text = file.read

data/lib/atome/atome.rb

@@ -14,15 +14,21 @@ class Atome
   def initialize(atomes = {}, &atomes_proc)
 
     atomes.each_value do |elements|
-      # the instance variable below contain the id all any atomes that need to be informed when changes occurs
-      @broadcast = {}
-      # now we store the proc in a an atome's property called :bloc
-      elements[:code] = atomes_proc if atomes_proc
-
-      @atome = elements
-      # we initiate the rendering suing set_type method,
-      # eg for for browser we will call :browser_type generate method in identity.rb file
-      collapse
+
+      if  Universe.atomes.key?(elements[:id])
+        puts "The id #{elements[:id]} is already taken, you must change it"
+        # `throw new Error("this id is already exist, you must change it");`
+      else
+        # the instance variable below contain the id all any atomes that need to be informed when changes occurs
+        @broadcast = {}
+        # # now we store the proc in a an atome's property called :bloc
+        elements[:code] = atomes_proc if atomes_proc
+
+        @atome = elements
+        # we initiate the rendering suing set_type method,
+        # eg for for browser we will call :browser_type generate method in identity.rb file
+        collapse
+      end
     end
   end
 
@@ -34,8 +40,12 @@ class Atome
         params = sanitize(element, params, &user_proc)
         create_particle(element, store, render)
         send("set_#{element}", params, &user_proc)
+      elsif element == :batch # TODO : find a better solution than a condition if possible
+        @atome[:batch]
       else
-        get_particle(element, &user_proc)
+
+        @atome[element]
+        # get_particle(element, &user_proc)
       end
     end
   end
@@ -50,51 +60,37 @@ class Atome
 
   def atome_parsing(element, params, &user_proc)
     params = sanitize(element, params)
-    current_atome = send(element).value
+    current_atome = send(element)
 
     # The condition below check if we need to add or replace the newly created atome
     if current_atome && !(@atome[:add] && @atome[:add][element])
       detached(current_atome)
       @atome[element] = []
     end
-
-
     # TODO :replace with the line below but need extensive testing as it crash some demos ex: animation
     params = atome_common(element, params)
-    # ############ code to remove below
-    # parent_found = found_parents_and_renderers[:parent]
-    # render_found = found_parents_and_renderers[:renderers]
-    # default_params = Essentials.default_params[element] || {}
-    # generated_id = params[:id] || identity_generator(element)
-    #
-    # default_params = { renderers: render_found, id: generated_id, type: element,
-    #                    attach: parent_found }.merge(default_params)
-    # params = default_params.merge(params).merge({ clones: [] })
-    # ############ code to remove above
-    # puts params[:renderers]
-    # puts params[:id]
-    # new_params= {renderers: params[:renderers], id:  params[:id]}.merge(params)
-    #
-    # params=new_params
-    # puts "new_params : #{params}"
-    ###
-    ###
-    # puts "params :\n #{params}\n\n, params2 :\n #{params2}"
     run_optional_proc("pre_render_#{@atome[:type]}".to_sym, self, params, &user_proc)
     run_optional_proc("post_render_#{@atome[:type]}".to_sym, self, params, &user_proc)
     send("set_#{element}", params, &user_proc) # it call  Atome.define_method "set_#{element}" in  new_atome method
   end
 
-  def new_atome(element, &method_proc)
+  def atome_catcher(atome_catch)
+    # puts "atome_catch is : #{atome_catch.class}"
+    atome_catch
+  end
 
+  def new_atome(element, &method_proc)
     # the method define below is the slowest but params are analysed and sanitized
     Atome.define_method element do |params = nil, &user_proc|
       if params
         instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
         atome_parsing(element, params, &user_proc)
       else
-        get_atome(element, &user_proc)
+        # puts "******> we are searching for the atome return(noobs) #{element} : #{id}"
+        # puts  "no atome params"
+        atome_catcher(@atome[element])
       end
+
     end
 
     # the method define below is the fastest params are passed directly
@@ -104,11 +100,13 @@ class Atome
       new_atome = Atome.new({ element => params }, &user_proc)
       # Now we return the newly created atome instead of the current atome that is the parent cf: b=box; c=b.circle
       # c must return the circle not the parent box
-      new_atome
+      # puts "******> we are searching for the atome return(set) #{element} : #{id}"
+      #   puts  "no set  atome params"
+      atome_catcher(new_atome)
+
     end
     # the method below generate Atome method creation at Object level
-    create_method_at_object_level(element)
-
+    # create_method_at_object_level(element)
   end
 
   def new_render_engine(renderer_name, &method_proc)
@@ -120,6 +118,12 @@ class Atome
   def run_optional_proc(proc_name, atome = self, params, &user_proc)
     # params = instance_variable_get("@#{element}")
     option_found = Universe.get_optional_method(proc_name)
+
+    # if option_found.is_a?(Proc)
+    #   # alert  "#{proc_name} : #{params} "
+    # else
+    #   puts "proc_name : #{proc_name}, \noption_found : (#{option_found})"
+    # end
     atome.instance_exec(params, user_proc, atome, &option_found) if option_found.is_a?(Proc)
   end
 
@@ -145,9 +149,9 @@ class Atome
     store_code_bloc(element, &user_proc) if user_proc
     # Params is now an instance variable so it should be passed thru different methods
     instance_variable_set("@#{element}", params) if store
-    run_optional_proc("pre_render_#{element}".to_sym, self, params, &user_proc)
+    run_optional_proc("pre_render_#{element}", self, params, &user_proc)
     rendering(element, params, &user_proc) if render
-    run_optional_proc("post_render_#{element}".to_sym, self, params, &user_proc)
+    run_optional_proc("post_render_#{element}", self, params, &user_proc)
     broadcasting(element)
     store_value(element) if store
     self
@@ -163,23 +167,5 @@ class Atome
     @atome[element]
   end
 
-  def get_particle(element, &user_proc)
-    virtual_atome = Atome.new({})
-    virtual_atome.value = (@atome[element])
-    virtual_atome.real_atome = @atome
-    virtual_atome.property = element
-    virtual_atome.user_proc = user_proc
-    virtual_atome
-  end
-
-  def get_atome(element, &user_proc)
-    virtual_atome = Atome.new({})
-    virtual_atome.real_atome = @atome
-    virtual_atome.property = element
-    virtual_atome.user_proc = user_proc
-    virtual_atome.value = @atome[element]
-    virtual_atome
-  end
-
   Universe.connected
 end

data/lib/atome/extensions/atome.rb

@@ -1,53 +1,83 @@
 # frozen_string_literal: true
-def new(params, &bloc)
-  generator = Genesis.generator
-  if params.key?(:particle)
-    # render indicate if the particle needs to be rendered
-    # store tell the system if it need to store the particle value
-    # type help the system what type of type the particle will receive and store
-    generator.build_particle(params[:particle], { render: params[:render],
-                                                  store: params[:store], type: params[:type] }, &bloc)
-  elsif params.key?(:atome)
-    generator.build_atome(params[:atome], &bloc)
-  elsif params.key?(:sanitizer)
-    generator.build_sanitizer(params[:sanitizer], &bloc)
-  elsif params.key?(:pre)
-    generator.build_option("pre_render_#{params[:pre]}", &bloc)
-  elsif params.key?(:post)
-    generator.build_option("post_render_#{params[:post]}", &bloc)
-  elsif params.key?(:browser)
-    generator.build_render("browser_#{params[:browser]}", &bloc)
-  end
-end
-
-def identity_generator(type = :element)
-  "#{type}_#{Universe.counter}"
-  # { date: Time.now, location: geolocation }
-end
-
-def grab(atome_to_get)
-  atome_to_get = atome_to_get.value if atome_to_get.instance_of? Atome
-  Universe.atomes[atome_to_get]
-end
-
-def box(params = {}, &proc)
-  grab(:view).box(params, &proc)
-end
-
-def circle(params = {}, &proc)
-  grab(:view).circle(params, &proc)
-end
-
-def matrix(params = {}, &proc)
-  grab(:view).matrix(params, &proc)
-end
-
-# the method below generate Atome method creation at Object level
-def create_method_at_object_level(element)
-
-  Object.define_method element do |params, &user_proc|
-    default_parent=Essentials.default_params[element][:attach][0] # we get the first parents
-    grab(default_parent).send(element, params, &user_proc)
-  end
-
-end
+
+class Object
+  def new(params, &bloc)
+    generator = Genesis.generator
+    if params.key?(:particle)
+      # render indicate if the particle needs to be rendered
+      # store tell the system if it need to store the particle value
+      # type help the system what type of type the particle will receive and store
+      generator.build_particle(params[:particle], { render: params[:render], return: params[:return],
+                                                    store: params[:store], type: params[:type] }, &bloc)
+    elsif params.key?(:atome)
+      atome_return = params[:return] || params[:atome]
+      generator.build_atome(params[:atome], &bloc)
+    elsif params.key?(:sanitizer)
+      generator.build_sanitizer(params[:sanitizer], &bloc)
+    elsif params.key?(:pre)
+      generator.build_option("pre_render_#{params[:pre]}", &bloc)
+    elsif params.key?(:post)
+      generator.build_option("post_render_#{params[:post]}", &bloc)
+    elsif params.key?(:browser)
+      generator.build_render("browser_#{params[:browser]}", &bloc)
+    end
+  end
+
+  def batch (atomes)
+    grab(:black_matter).batch(atomes)
+  end
+
+  def identity_generator(type = :element)
+    "#{attach[0]}_#{type}_#{Universe.counter}"
+  end
+
+  def grab(atome_to_get)
+
+    Universe.atomes[atome_to_get]
+  end
+
+  def box(params = {}, &proc)
+    grab(:view).box(params, &proc)
+  end
+
+  def circle(params = {}, &proc)
+    grab(:view).circle(params, &proc)
+  end
+
+  def matrix(params = {}, &proc)
+    grab(:view).matrix(params, &proc)
+  end
+
+  # def method_missing(method, *args, &block)
+  #   args.each do |atome_found|
+  #     args.each do |arg|
+  #       default_parent = Essentials.default_params[method][:attach][0] # we get the first parents
+  #       # create_method_at_object_level(element)
+  #       atome_found = grab(default_parent).send(method, arg, &block)
+  #       # we force then return of atome found else its return an hash # TODO : we may find a cleaner solution
+  #       return atome_found
+  #     end
+  #   end
+  # end
+
+  # the method below generate Atome method creation at Object level
+  def atome_method_for_object(element)
+
+    Object.define_method element do |params, &user_proc|
+      default_parent = Essentials.default_params[element][:attach][0] # we get the first parents
+      grab(default_parent).send(element, params, &user_proc)
+    end
+  end
+
+  def atome_method_for_batch(element)
+    Batch.define_method element do |params, &user_proc|
+      dispatch(element, [params], &user_proc)
+    end
+  end
+  def particle_method_for_batch(element)
+    Batch.define_method element do |params, &user_proc|
+      dispatch(element, [params], &user_proc)
+    end
+  end
+
+end

data/lib/atome/extensions/mathematic.rb

@@ -1,24 +1,20 @@
 # frozen_string_literal: true
 
 class Atome
-  def /val
-    val=val.value if val.instance_of? Atome
-    value/val
+  def /(val)
+    value / val
   end
 
-  def *val
-    val=val.value if val.instance_of? Atome
-    value*val
+  def *(val)
+    value * val
   end
 
-  def -val
-    val=val.value if val.instance_of? Atome
-    value-val
+  def -(val)
+    value - val
   end
 
 
-  def +val
-    val=val.value if val.instance_of? Atome
-    value+val
+  def +(val)
+    value + val
   end
 end