atome 0.5.2.5 → 0.5.2.8

data/lib/atome/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Atome
-  VERSION = '0.5.2.5'
+  VERSION = '0.5.2.8'
 end

data/lib/atome.rb

@@ -21,6 +21,7 @@ require 'atome/genesis/generators/geometry'
 require 'atome/genesis/generators/identity'
 require 'atome/genesis/generators/material'
 require 'atome/genesis/generators/spatial'
+require 'atome/genesis/generators/time'
 require 'atome/genesis/generators/utility'
 if RUBY_ENGINE.downcase == 'opal'
   require 'atome/renderers/browser/browser'

data/sig/atome.rbs

@@ -1,5 +1,11 @@
 module Atome
   VERSION: String
   # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  def add: -> untyped
+
+  def add_to_array: -> untyped
+
+  def add_to_hash: -> untyped
+
   def sort_callback: -> untyped
 end

data/vendor/assets/server/atome_server.rb

@@ -2,7 +2,7 @@
 
 # atome server
 require 'em/pure_ruby' if RUBY_PLATFORM == 'x64-mingw32'
-require  'atome'
+# require  'atome'
 require '../aui'
 require 'digest/sha2'
 require 'faye/websocket'
@@ -80,11 +80,11 @@ class App < Roda
   puts "The average price is: #{items.avg(:width)}"
 
 
-  index_content = File.read("../build/index.html")
+  index_content = File.read("../src/index.html")
 
 
-  opts[:root] = '../build'
-  plugin :static, %w[/css /js /medias], root: '../build'
+  opts[:root] = '../src'
+  plugin :static, %w[/css /js /medias], root: '../src'
   route do |r|
     if Faye::WebSocket.websocket?(env)
       websocket = Faye::WebSocket.new(env)

data/vendor/assets/server/config.ru

@@ -5,4 +5,8 @@ require 'rack/unreloader'
 
 Unreloader = Rack::Unreloader.new(subclasses: %w[Roda]) { App }
 Unreloader.require './atome_server.rb'
-run Unreloader
+run Unreloader
+# uncomment to allow code reloading
+# uncomment below for prod or comment to allow code reloading
+#run App.freeze.app
+

data/vendor/assets/{build → src}/medias/rubies/examples/_2_solve.rb

@@ -55,4 +55,4 @@ b.box()
 
 b=box
 c=b.box
-c.left(200)
+c.left(200)

data/vendor/assets/src/medias/rubies/examples/_dataset.rb

@@ -0,0 +1,177 @@
+# # frozen_string_literal: true
+
+# generator = Genesis.generator
+# generator.build_atome(:data_set)
+# generator.build_particle(:assign) do |cell_nb,&proc |
+#     # current_cell = grab("#{@matrix_id}_#{cell_nb}")
+#     if proc
+#       # @matrix_dataset[cell_nb] << proc
+#       # current_cell.instance_exec(&proc) if proc.is_a? Proc
+#     else
+#       # @matrix_dataset[cell_nb]
+#     end
+# end
+# class Atome
+#   def data_set(params = {}, &bloc)
+#     atome_type = :data_set
+#     generated_render = params[:renderers] || []
+#     generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
+#     generated_parents = params[:parents] || [id.value]
+#     params = atome_common(atome_type, generated_id, generated_render, generated_parents, params)
+#     Atome.new({ atome_type => params }, &bloc)
+#   end
+# end
+#
+#
+# # create_atome(:data_set)
+#
+# a = data_set({})
+# puts a
+#
+# a.assign(2) do
+#   curent_cell = self
+#   curent_cell.image({ path: "./medias/images/moto.png", width: 33, height: 33})
+#   curent_cell.active(:inactive)
+#   touch(:long) do
+#     if curent_cell.active.value ==:inactive
+#       curent_cell.color(:yellow)
+#       curent_cell.active(:active)
+#     else
+#       curent_cell.color(:red)
+#       curent_cell.active(:inactive)
+#     end
+#   end
+# end
+#
+#*
+# a.assign(3) do
+#   color({ red: 0.6, green: 0.333, blue: 0.6, alpha: 1 })
+#   grab(:vie_playground_3).shadow({ blur: 12 })
+# end
+# puts  "assign : #{a.assign}"
+
+box({id: :the_box})
+circle({top: 300, id: :circle098})
+generator = Genesis.generator
+
+generator.build_atome(:template)
+generator.build_particle(:cells)
+generator.build_particle(:rows)
+generator.build_particle(:columns)
+generator.build_sanitizer(:template) do |params|
+  default_params = { renderers: [], id: "template_#{Universe.atomes.length}", type: :template }
+  default_params.merge!(params)
+end
+
+def resize_matrix(params)
+  matrix=params[:matrix]
+  matrix_width = params[:width]
+  matrix_height = params[:height]
+  cells=params[:cells]
+  nb_of_cols= params[:columns]
+  nb_of_rows= params[:rows]
+  margin=params[:margin]
+  cell_width = (matrix_width / nb_of_cols) - margin
+  cell_height = (matrix_height / nb_of_rows) - margin
+  row = -1
+  cells.each_with_index do |cell, index|
+    cell.height = cell_height
+    cell.width = cell_width
+    row += 1 if index.modulo(nb_of_cols).zero?
+    cell.left(index % nb_of_cols * (cell_width + margin) + margin)
+    cell.top(row * (cell_height + margin) + margin)
+  end
+
+  matrix.width = matrix_width + margin
+  matrix.height = matrix_height + margin
+end
+
+generator.build_particle(:display) do |params|
+
+  template_needed = params[:template]
+  targeted_atomes = params[:list] ||= []
+  sort_by=params[:sort]
+
+
+  # alert "template to get #{template_needed}"
+  # alert "add this to cells #{targeted_atomes}"
+  template_grab=grab(template_needed)
+  # alert template_grab
+  matrix_back_color=create_matrix_colors('matrix_color_back',0.3,0.3,0.6,1)
+  cell_back_color=create_matrix_colors('cell_color_back',0.333,0.333,0.7,1)
+  matrix_back_id="matrix_back_display_nb"
+  matrix_back=create_matrix_back( matrix_back_id, { width: 33, smooth: 9 })
+  matrix_back_color.attach([matrix_back_id])
+
+  cells=create_matrix_cells(matrix_back_id,cell_back_color,33,{width: 33, height: 33,
+                                                               smooth: 9,shadow: { blur: 6 }})
+  resize_matrix({matrix: matrix_back, width: 333, height: 333, cells: cells, columns: 2, rows: 8, margin: 9 })
+  # We sort, clone and put the target in the matrix
+  sorted={}
+  targeted_atomes.each_with_index  do |atome_id, index|
+    atome_found=grab(atome_id)
+    clone= atome_found.clones([{left: 33}])
+    selected_id="#{matrix_back_id}_#{index}"
+    clone.parents([selected_id])
+    cell_height=grab(selected_id).height.value-9
+
+    clone.left=3
+    clone.top=3
+    clone.width(cell_height)
+    clone.height(cell_height)
+    sorted[atome_id]=atome_found.atome[sort_by]
+
+
+  end
+  # alert "==> not sorted #{sorted}"
+  sorted=sorted.sort_by {|_key, value| value}.to_h
+  # alert "**> sorted #{sorted}"
+
+  selected=params[:select] ||= []
+  selected.each do |select|
+    selected_id="#{matrix_back_id}_#{select}"
+    grab(selected_id).color(:red)
+  end
+end
+
+def create_matrix_colors(name,red,green,blue,alpha)
+  Atome.new({ color: { renderers: [:browser], id: name, type: :color, parents: [], children: [],
+                       red: red, green: green, blue: blue, alpha: alpha  } })
+end
+
+def create_matrix_back( id, style)
+  matrix = Atome.new(
+    shape: { type: :shape, renderers: [:browser], id: id, parents: [:view],width: 333, height: 333,left: 333,
+             overflow: :hidden,children: [] }
+  )
+  matrix.style(style)
+  matrix
+end
+
+
+def create_matrix_cells(id,cell_back_color, number_of_cells, style)
+  counter=0
+  cells=[]
+  while counter < number_of_cells
+    id_generated=id + "_#{counter}"
+    cells << a = Atome.new(
+      shape: { type: :shape, renderers: [:browser], id: id_generated, parents: [id],
+               children: [:cell_color]
+
+               }
+    )
+    cell_back_color.attach([id_generated])
+    a.style(style)
+    counter += 1
+  end
+  cells
+end
+
+
+
+template({ id: :child_in_table, code: [], cells: 16, columns: 4, rows: 4 })
+the_view = grab(:view)
+the_view.display(template: :child_in_table,sort: :id, list: [:the_box,:circle098], left: 33, top: 63, width: 333, height: 333)
+
+  the_view.display({ select: [1, 3, 7], id: :child_in_table })
+

data/vendor/assets/src/medias/rubies/examples/_test.rb

@@ -0,0 +1 @@
+# frozen_string_literal: true