atome 0.5.7.0.3 → 0.3191

data/lib/atome/atome_native_extensions.rb

@@ -0,0 +1,3 @@
+require 'atome/extensions/sha'
+require 'atome/extensions/ping'
+require 'atome/extensions/geolocation'

data/lib/atome/extensions/geolocation.rb

@@ -2,7 +2,6 @@
 
 require 'geocoder'
 
-# add on for the atome method
 class Atome
   def geolocation
     # native version
@@ -11,3 +10,4 @@ class Atome
     results.first.coordinates
   end
 end
+

data/lib/atome/extensions/ping.rb

@@ -1,14 +1,15 @@
-# frozen_string_literal: true
+def ping(address, my_proc: false)
+  # if  RUBY_ENGINE.downcase != 'opal'
 
-# ping method
-class Atome
-  def up?(host, _my_proc)
+  def up?(host, my_proc)
     check = Net::Ping::External.new(host)
-    return unless check.ping?
-    'ping respond!!'
+    if check.ping?
+      puts my_proc
+    end
   end
 
-  def ping(address, my_proc: false)
-    up(address, my_proc) # prints "true" if ping replies
-  end
-end
+  chost = address
+  puts up?(chost, my_proc) # prints "true" if ping replies
+
+  # end
+end

data/lib/atome/extensions/sha.rb

@@ -1,8 +1,6 @@
-# # frozen_string_literal: true
-#
-# # to create a hash
-# class Atome
-#   def calculate_sha(string)
-#     Digest::SHA256.hexdigest(string)
-#   end
-# end
+class Atome
+  def calculate_sha(string)
+    Digest::SHA256.hexdigest(string)
+  end
+end
+

data/lib/atome/kernel/atome_genesis.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+# here is the atome kernel
+
+# todo :
+# Id generator
+# Add missing params (methods for noobs only?)
+# Sanitizer (methods for noobs only?)
+# Sort params (methods for noobs only?)
+# Pre-processor
+# Renderer
+# Store
+# Post-processor
+# Add or set
+# Getter
+# parental
+
+# This is the main entry for Atome class
+
+# TODO: modify html file to be able to add meta data
+class Atome
+  include AtomeGeometryMethods
+
+  # def current_machine
+  #   platform = RUBY_PLATFORM.downcase
+  #   output = `#{(platform =~ /win32/) ? 'ipconfig /all' : 'ifconfig'}`
+  #   case platform
+  #   when /darwin/
+  #     $1 if output =~ /en1.*?(([A-F0-9]{2}:){5}[A-F0-9]{2})/im
+  #   when /win32/
+  #     $1 if output =~ /Physical Address.*?(([A-F0-9]{2}-){5}[A-F0-9]{2})/im
+  #     # Cases for other platforms...
+  #   else
+  #     nil
+  #   end
+  #   # todo check the code above and create a sensible identity
+  #   platform
+  # end
+
+  def self.current_user
+    @user
+  end
+
+  def self.current_user=(user)
+    # TODO: create or load an existing user
+    # if user needs to be create the current_user will be eVe
+    @user = user
+  end
+
+  # def id_generator(number)
+  #   charset = Array('A'..'Z') + Array('a'..'z') + Array(0...9)
+  #   Array.new(number) { charset.sample }.join
+  #   # "#{Atome.current_user}_#{current_machine}_#{location}_#{(Time.now.to_f * 1000).to_i}"
+  #   # "object_#{Universe.atomes.length}"
+  # end
+
+  def identity_generator
+    {date: Time.now, location: geolocation}
+  end
+
+  def initialize(params = {})
+    default_params = { render: [{ engine: [{ value: :html }] }], type: [{ value: :particle }] }
+    # primary_id="#{id_generator(9)}_#{params.keys[0]}".to_sym
+    aui = "#{Atome.current_user}_#{Universe.app_identity}_#{Universe.atomes.length}}"
+    # puts "aui is : #{aui}"
+    params = default_params.merge(params).merge(identity: identity_generator)
+    # puts params
+    @atome = {}
+    # puts "-----------------"
+    params.each do |property, value|
+      @atome[property] = value
+    end
+    # puts "-----------------"
+
+    Universe.atomes_add(aui, @atome)
+  end
+
+  def properties_common(property, value, dynamic, optional_processing)
+    # stack_property, optional_processor
+    if value.nil?
+      # the method is a getter
+      @atome[property]
+    else
+      # here we set the value to the property
+      @atome[property] = value
+      # atome_router(property, value, dynamic, optional_processing)
+    end
+  end
+end
+
+# initialize Universe
+Universe.connected
+# Atome.new( identity: {type: :eVe, aui: :a_97987987987})
+# puts "is anyone connected"

data/lib/atome/kernel/generators/shapes.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+def box(params = {}, formated = false)
+  puts params
+  formated
+  Atome.new(color: {})
+end

data/lib/atome/kernel/properties/geometry.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+# here are the geometry  properties of atome
+module AtomeGeometryMethods
+  # def dummy(value = nil, stack_property = nil)
+  #   property = :dummy
+  #   optional_processor = { pre_process: true, post_process: true, store_atome: false, render_atome: false }
+  #   properties_common(property, value, stack_property, optional_processor)
+  # end
+  # def universe(value = nil, stack_property = nil)
+  #   property = :universe
+  #   optional_processor = {}
+  #   # properties_common(property, value, stack_property, optional_processor)
+  # end
+
+  def color(params, formatted: false)
+    p formatted
+    puts "params #{params} must be formatted"
+    "colorized"
+  end
+
+  def parent(value = nil, stack_property = nil)
+    property = :parent
+    optional_processor = { pre_process: true, post_process: true }
+    properties_common(property, value, stack_property, optional_processor)
+  end
+
+  def left(value = nil, stack_property = nil)
+    property = :left
+    optional_processor = {}
+    properties_common(property, value, stack_property, optional_processor)
+  end
+
+  def top(value = nil, stack_property = nil)
+    property = :top
+    optional_processor = {}
+    properties_common(property, value, stack_property, optional_processor)
+  end
+
+  #
+  # def bottom(value = nil, stack_property = nil)
+  #   property = :bottom
+  #   optional_processor = {}
+  #   properties_common(property, value, stack_property, optional_processor)
+  # end
+  #
+  def right(value = nil, stack_property = nil)
+    property = :right
+    optional_processor = {}
+    properties_common(property, value, stack_property, optional_processor)
+  end
+  #
+  # def child(value = nil, stack_property = nil)
+  #   property = :child
+  #   optional_processor = {}
+  #   properties_common(property, value, stack_property, optional_processor)
+  # end
+  #
+  # def id(value = nil, stack_property = nil)
+  #   property = :id
+  #   optional_processor = {}
+  #   properties_common(property, value, stack_property, optional_processor)
+  # end
+  #
+  # def name(value = nil, stack_property = nil)
+  #   property = :name
+  #   optional_processor = {}
+  #   properties_common(property, value, stack_property, optional_processor)
+  # end
+  #
+  # def view(value = nil, stack_property = nil)
+  #   property = :view
+  #   optional_processor = {}
+  #   properties_common(property, value, stack_property, optional_processor)
+  # end
+  #
+  # def type(value = nil, stack_property = nil)
+  #   property = :type
+  #   optional_processor = {}
+  #   properties_common(property, value, stack_property, optional_processor)
+  # end
+  #
+  # def preset(value = nil, stack_property = nil)
+  #   property = :preset
+  #   optional_processor = {}
+  #   properties_common(property, value, stack_property, optional_processor)
+  # end
+  #
+
+  #
+  # def red(value = nil, stack_property = nil)
+  #   property = :red
+  #   optional_processor = {}
+  #   properties_common(property, value, stack_property, optional_processor)
+  # end
+  #
+  # def green(value = nil, stack_property = nil)
+  #   property = :green
+  #   optional_processor = {}
+  #   properties_common(property, value, stack_property, optional_processor)
+  # end
+  #
+  # def blue(value = nil, stack_property = nil)
+  #   property = :blue
+  #   optional_processor = {}
+  #   properties_common(property, value, stack_property, optional_processor)
+  # end
+  #
+  # def alpha(value = nil, stack_property = nil)
+  #   property = :alpha
+  #   optional_processor = {}
+  #   properties_common(property, value, stack_property, optional_processor)
+  # end
+  #
+  # def radiation(value = nil, stack_property = nil)
+  #   property = :radiation
+  #   optional_processor = {}
+  #   properties_common(property, value, stack_property, optional_processor)
+  # end
+end

data/lib/atome/kernel/universe.rb

@@ -1,305 +1,34 @@
 # frozen_string_literal: true
+# all created atomes are listed here
 
-# universe method here
 class Universe
-  @counter = 0
-  @atomes = {}
-  @atomes_ids = {}
-  @atome_list = []
-  @molecule_list = []
-  @particle_list = {}
-  @renderer_list = %i[html browser headless server log]
-  @sanitizers = {}
-  @specificities = {}
-  @messages = {}
-  @increment = 0
-  @categories = %w[atome communication effect event geometry hierarchy identity material
-                  property security spatial time utility ]
-  @history = {}
-  @users = {}
-  @help = {}
-  @example = {}
-  @allow_localstorage = false # temp storage boolean
-  @allow_sync = false # temp server storage sync
-  @connected = false
-  @database_ready = false
-  @tools = {}
-  @allow_tool_operations = false
-  @active_tools = []
-  @atome_preset = []
-  # @historicize=false
-  class << self
-    attr_reader :atomes, :atomes_ids, :renderer_list, :molecule_list, :atome_list, :particle_list, :classes, :counter,
-                :atomes_specificities
-    attr_accessor :connected, :allow_sync, :allow_localstorage, :database_ready, :edit_mode, :tools,
-                  :allow_tool_operations, :active_tools, :atome_preset
-
-    def messages
-      @messages
-    end
-
-    # def eVe(val = nil)
-    #   if val
-    #     @eve = val
-    #   else
-    #     @eve
-    #   end
-    # end
-
-    def store_messages(new_msg)
-      @messages[new_msg[:msg_nb]] = new_msg[:proc]
-    end
-
-    def delete_messages(msg_to_del)
-      @messages.delete(msg_to_del)
-    end
-
-    def set_help(particle, &doc)
-      @help[particle] = doc
-    end
-
-    def get_help(particle)
-      @help[particle]
-    end
-
-    def set_example(particle, &example)
-      @example[particle] = example
-    end
-
-    def get_example(particle)
-      @example[particle]
-    end
-
-    def categories
-      @categories
-    end
-
-    def add_to_particle_list(particle = nil, type, category)
-      # instance_variable_get('@particle_list')[particle] = { type: type, category: category }
-      @particle_list[particle] = { type: type, category: category }
-    end
-
-    def add_atomes_specificities atome_type_to_add
-      @specificities[atome_type_to_add] = {}
-    end
-
-    def set_atomes_specificities params
-      particle_found = params[:method].to_sym
-      specificity = "#{params[:specific]}_".to_sym
-      @specificities[params[:specific]][particle_found] = specificity
-    end
-
-    def get_atomes_specificities
-      @specificities
-    end
-
-    def add_sanitizer_method(method_name, &method_proc)
-      # this method is used to add sanitizer methods
-      # instance_variable_get('@sanitizers').merge!({ method_name => method_proc })
-      @sanitizers.merge!({ method_name => method_proc })
-    end
-
-    def get_sanitizer_method(method_name)
-      # this method is used to add optional methods
-      # instance_variable_get('@sanitizers')[method_name]
-      @sanitizers[method_name]
-    end
-
-    def add_to_atome_list(atome)
-      @atome_list.push(atome)
-    end
-
-    def add_to_molecule_list(molecule)
-      @molecule_list.push(molecule)
-    end
-
-    def add_to_atomes(aid, atome)
-      @atomes[aid] = atome
-      @counter = @counter + 1
-    end
-
-    def id_to_aid(id, aid)
-      @atomes_ids[id] = aid
-    end
-
-    # def update_atome_id(aid, atome, prev_id)
-    #   @atomes[id] = atome
-    #   @atomes.delete(prev_id)
-    # end
-    # def update_atome_id(id, atome, prev_id)
-    #   @atomes[id] = atome
-    #   @atomes.delete(prev_id)
-    # end
-
-    def user_atomes
-      collected_id = []
-      @atomes.each do |id_found, atome_found|
-        # collected_id << id_found unless atome_found.tag && atome_found.tag[:system]
-        collected_id << atome_found.id unless atome_found.tag && atome_found.tag[:system]
-
-      end
-      collected_id
-    end
-
-    def system_atomes
-      collected_id = []
-      @atomes.each do |id_found, atome_found|
-        collected_id << id_found if atome_found.tag && atome_found.tag[:system]
-      end
-      collected_id
-    end
-
-    def generate_uuid
-      uuid = SecureRandom.uuid.gsub('-', '')
-      formatted_time = Time.now.strftime("%Y%m%d%H%M%S")
-      "#{uuid}#{formatted_time}"
-    end
-
-    def app_identity
-      # each app has its own identity, this allow to generate new user identities from the
-      # unique_id = generate_unique_id_with_timestamp
-      @app_identity = generate_uuid
-      # the identity is define as follow : parentsCreatorID_softwareInstanceID_objetID
-      # in this case parents is eve so 0, Software instance number is main eVe server which is also 0,
-      # and finally the object is 3 as this the third object created by the main server
-    end
-
-    def delete(id)
-      @atomes.delete(id)
-    end
-
-    def current_machine_decision(platform, output)
-      case platform
-      when /darwin/
-        ::Regexp.last_match(1) if output =~ /en1.*?(([A-F0-9]{2}:){5}[A-F0-9]{2})/im
-      when /win32/
-        ::Regexp.last_match(1) if output =~ /Physical Address.*?(([A-F0-9]{2}-){5}[A-F0-9]{2})/im
-      else
-        # Cases for other platforms...
-        'unknown platform'
-      end
-      platform
-    end
-
-    def platform_type
-      case RUBY_PLATFORM
-      when /win/i
-        "Windows"
-      when /darwin/i
-        "macOS"
-      when /linux/i
-        "Linux"
-      when /unix/i
-        "Unix"
-      else
-        "Plate-forme inconnue"
-      end
-    end
-
-    def engine
-      platform = RUBY_PLATFORM.downcase
-      output = if platform == :opal
-                 platform = JS.global[:navigator][:userAgent].to_s.downcase
-                 platform.include?('win32') ? 'ipconfig /all' : 'ifconfig'
-                 # `#{platform =~ /win32/ ? 'ipconfig /all' : 'ifconfig'}`
-               elsif platform == 'wasm32-wasi'
-                 'ifconfig'
-               elsif platform_type == :windows
-                 'ipconfig'
-               else
-                 'ifconfig'
-               end
-      current_machine_decision(platform, output)
-      # TODO: check the code above and create a sensible identity
-    end
-
-    def current_server
-      # return unless RUBY_ENGINE.downcase == 'opal'
-      JS.global[:location][:href].to_s
-    end
-
-    def current_user
-      @user
-    end
-
-    def add_user=(id)
-      @users[id] = true
-    end
-
-    def users
-      @users
-    end
-
-    def current_user=(user_id)
-      # TODO: create or load an existing user
-      # if user needs to be create the current_user will be eVe
-      @user = user_id
-    end
-
-    def current_machine
-      @machine
-    end
-
-    def current_machine=(machine_id)
-      # TODO: create or load an existing user
-      # if user needs to be create the current_user will be eVe
-      @machine = machine_id
-    end
-
-    def internet
-      if RUBY_ENGINE.downcase != :native
-        grab(:view).html.internet
-      else
-        # write code here for native
-      end
-    end
-
-    def synchronised(action_nb, pass)
-      return unless Black_matter.encode(pass) == Black_matter.password[:read][:atome]
-
-      @history[action_nb][:sync] = true
-    end
-
-    def historicize(id, operation, element, params)
-
-      if @allow_sync && Universe.connected
-        A.sync({ action: :historicize, data: { table: :user } })
-      end
-
-      # if @allow_localstorage && @database_ready
-      if @allow_localstorage
+  def self.app_identity
+    # each app hav its own identity, this allow to generate new user identities from th
+    @app_identity = 3
+    # the identity is define as follow : parentCreatorID_softwareInstanceID_objetID
+    # in this case parent is eve so 0, Software instance number is main eVe server which is also 0,
+    # and finally the object is 3 as this the third object created by the main server
+  end
 
-        operation_timing = Time.now.strftime("%Y%m%d%H%M%S%3N") + @increment.to_s
-        @increment += 1
-        @increment = @increment % 100
-        # puts "===> { #{id} => { #{operation} => { #{element} => #{params} } }, sync: false }"
-        # puts "<==== #{@allow_localstorage} : #{element} ====>"
-        if @allow_localstorage.include? element
-          JS.global[:localStorage].setItem(operation_timing, "{ #{id} => { #{operation} => { #{element} => #{params} } }, sync: false }")
-          @history[@history.length] = { operation_timing => { id => { operation => { element => params } }, sync: false, time: Time.now } }
-          puts "===> { #{id} => { #{operation} => { #{element} => #{params} } }, sync: false }"
-        end
+  def self.initialize
+    @atomes = {}
+  end
 
+  def self.atomes_add(atome_id,new_atome)
+    @atomes[atome_id] = new_atome
+  end
 
-      end
-    end
+  def self.atomes
+    @atomes
+  end
 
-    def story
-      @history
-      # # temp algo awaiting db to be ready, just for POC and tests
-      # return unless filter
-      #
-      # operation = filter[:operation]
-      # atome_id = filter[:id]
-      # particle = filter[:particle]
-      # filtered_history = []
-      # @history.each do |operation_number, alteration|
-      #   if alteration[atome_id] && (alteration[atome_id][operation]) && (alteration[atome_id][operation][particle])
-      #     filtered_history << { operation: operation_number, filter[:particle] => alteration[atome_id][operation][particle], sync: alteration[:sync], time: alteration[:time] }
-      #   end
-      # end
-      # filtered_history
-    end
+  class << self
+    attr_reader :atomes
+  end
 
+  def self.connected
+    true
   end
+
 end
+

data/lib/atome/renderers/opal/atome_opal_extensions.rb

@@ -0,0 +1,4 @@
+require 'extensions/geolocation'
+require 'extensions/ping'
+require 'extensions/sha'
+require 'properties/generator'

data/lib/{platform_specific → atome/renderers}/opal/extensions/geolocation.rb

@@ -1,4 +1,3 @@
-# frozen_string_literal: true
 
 class Atome
   def geolocation
@@ -6,6 +5,7 @@ class Atome
     $window.navigator.geolocate.then do |pos|
       localisation[:latitude] =  pos.coords.latitude
       localisation[:longitude] =  pos.coords.longitude
+      # alert self.inspect
     end.rescue do |err|
       p  err
       localisation = nil

data/lib/atome/renderers/opal/extensions/ping.rb

@@ -0,0 +1,13 @@
+class Atome
+  def ping(address, my_proc=false)
+    ` var p = new Ping();
+        p.ping('https://'+#{address}+'', function (err, data) {
+            if (err) {
+               return false;
+            } else {
+ console.log("the site "+#{address}+" is up!");
+            }
+        });
+`
+  end
+end

data/lib/atome/renderers/opal/extensions/sha.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+class Atome
+  def calculate_sha(string)
+    # if RUBY_ENGINE.downcase == 'opal'
+    `sha256(#{string})`
+    # else
+    #   Digest::SHA256.hexdigest(string)
+    # end
+  end
+end
+

data/lib/atome/renderers/opal/opal_browser.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# render methods
+require 'opal'
+require 'native'
+require 'promise'
+require 'browser/setup/full'
+@atome_client_ready=true

data/lib/{platform_specific → atome/renderers}/opal/opal_parser.rb

@@ -1,3 +1,2 @@
 # frozen_string_literal: true
-
 require 'opal-parser'

data/lib/atome/renderers/opal/properties/generator.rb

@@ -0,0 +1,6 @@
+
+class Atome
+  def shape(params)
+    `alert('building shapes with params')`
+  end
+end

data/lib/atome/version.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-#  return atome version
 class Atome
-  VERSION = '0.5.7.0.3'
+  VERSION = '0.3191'
 end