atome 0.5.4.1.9 → 0.5.5.6.4

data/lib/atome/genesis/sparkle.rb

@@ -1,121 +1,105 @@
 # frozen_string_literal: true
 
-# let's create the Universe
-def eval_protection
-  binding
-end
-
-# Let's set the default's parameters according to ruby interpreter
-if RUBY_ENGINE.downcase == 'opal'
-  Essentials.new_default_params({ render_engines: [:browser] })
-else
-  Essentials.new_default_params({ render_engines: [:headless] })
-  eval "require 'atome/extensions/geolocation'", eval_protection, __FILE__, __LINE__
-  eval "require 'atome/extensions/ping'", eval_protection, __FILE__, __LINE__
-  eval "require 'atome/extensions/sha'", eval_protection, __FILE__, __LINE__
-end
-
 # now let's get the default render engine
-default_render = Essentials.default_params[:render_engines]
 
+# Lets create the U.I.
 
-def atome_infos
-  puts "atome version: #{Atome::VERSION}"
-  # puts "application identity: #{Universe.app_identity}"
-  puts "application identity:  #{Atome::aui}"
-  # puts "application mode:  #{Atome.mode}"
-  puts "host framework:  #{$host}"
-  puts "script mode: #{Universe.current_machine}"
-  puts "user: #{Universe.current_user}"
-  puts "server: #{Universe.current_server}"
-end
-
-Universe.current_user = :jeezs
-
-
-atome_infos
-
+default_render = Essentials.default_params[:render_engines]
 Atome.new(
-  { element: { renderers: [], id: :eDen, type: :element , tag: {system: true}} }
+  { renderers: [], id: :eDen, type: :element, tag: { system: true } }
 )
-
 Atome.new(
-  { element: { renderers: [], id: :user_view, type: :element, tag: {system: true},
-attach: [:eDen] } }
+  { renderers: [], id: :user_view, type: :element, tag: { system: true },
+    attach: :eDen }
 )
 
 # color creation
 Atome.new(
-  { color: { renderers: default_render, id: :view_color, type: :color,tag: ({persistent: true}),
-             red: 0.15, green: 0.15, blue: 0.15, alpha: 1 } }
+  { renderers: default_render, id: :view_color, type: :color, tag: ({ system: true, persistent: true }),
+    red: 0.15, green: 0.15, blue: 0.15, alpha: 1, top: 12, left: 12, diffusion: :linear }
 )
 
 Atome.new(
-  { color: { renderers: default_render, id: :shape_color, type: :color,tag: ({persistent: true}),
-             red: 0.4, green: 0.4, blue: 0.4, alpha: 1 } }
+  { renderers: default_render, id: :shape_color, type: :color, tag: ({ system: true, persistent: true }),
+    red: 0.4, green: 0.4, blue: 0.4, alpha: 1 }
 )
 
 Atome.new(
-  { color: { renderers: default_render, id: :box_color, type: :color,tag: ({persistent: true}),
-             red: 0.5, green: 0.5, blue: 0.5, alpha: 1 } }
+  { renderers: default_render, id: :box_color, type: :color, tag: ({ system: true, persistent: true }),
+    red: 0.5, green: 0.5, blue: 0.5, alpha: 1 }
 )
 
 Atome.new(
-  { color: { renderers: default_render, id: :invisible_color, type: :color,tag: ({persistent: true}),
-             red: 0, green: 0, blue: 0, alpha: 1 } }
+  { renderers: default_render, id: :invisible_color, type: :color, tag: ({ system: true, persistent: true }),
+    red: 0, green: 0, blue: 0, alpha: 1 }
 )
 
 Atome.new(
-  { color: { renderers: default_render, id: :text_color, type: :color,tag: ({persistent: true}),
-             red: 0.3, green: 0.3, blue: 0.3, alpha: 1 } }
+  { renderers: default_render, id: :text_color, type: :color, tag: ({ system: true, persistent: true }),
+    red: 0.9, green: 0.9, blue: 0.9, alpha: 1 }
 )
 
 Atome.new(
-  { color: { renderers: default_render, id: :circle_color, type: :color,tag: ({persistent: true}),
-             red: 0.6, green: 0.6, blue: 0.6, alpha: 1 } }
-)
-
-Atome.new(
-
-  { color: { renderers: default_render, id: :matrix_color, type: :color,tag: ({persistent: true}),
-             left: 0, top: 0, red: 0.7, green: 0.7, blue: 0.7, alpha: 1, diffusion: :linear } }
+  { renderers: default_render, id: :circle_color, type: :color, tag: ({ system: true, persistent: true }),
+    red: 0.6, green: 0.6, blue: 0.6, alpha: 1 }
 )
 
 # system object creation
 # the black_matter is used to store un materialized atomes
 Atome.new(
-  { shape: { renderers: default_render, id: :black_matter, type: :shape, attach: [:user_view],
-             left: 0, right: 0, top: 0, bottom: 0, width: 0, height: 0, overflow: :hidden, tag: {system: true}
-  } })
+  { renderers: default_render, id: :black_matter, type: :shape, attach: :user_view,
+    left: 0, right: 0, top: 0, bottom: 0, width: 0, height: 0, overflow: :hidden, tag: { system: true }
+  })
 
 # view port
 Atome.new(
-  { shape: { renderers: default_render, id: :view, type: :shape, attach: [:user_view], tag: {system: true},
-             attached: :view_color, left: 0, right: 0, top: 0, bottom: 0, width: :auto, height: :auto, overflow: :auto,
-  }
+  { renderers: default_render, id: :view, type: :shape, attach: :user_view, apply: [:view_color],
+    tag: { system: true }, left: 0, right: 0, top: 0, bottom: 0, width: :auto, height: :auto, overflow: :auto,
   }
+
 )
 
-#unreal port
+# unreal port, hold system object and tools
 Atome.new(
-  { shape: { renderers: default_render, id: :intuition, type: :shape, attach: [:user_view], tag: {system: true},
-             left: 0,  top: 0, width: 0, height: 0, overflow: :visible,
-  }
+  { renderers: default_render, id: :intuition, type: :shape, attach: :user_view, tag: { system: true },
+    left: 0, top: 0, width: 0, height: 0, overflow: :visible
   }
 )
 
-# init basic object for atome environment
+machine_id = :dummy_machine
+# attention we must used two separate pass to avoid the password to be encode twice
+machine_password = { read: { atome: :star_wars }, write: { atome: :star_wars } }
+user_password = { read: { atome: :star_wars }, write: { atome: :star_wars } }
 
-# Atome.new is used  to create a new atome using best performances but params must be formatted and ordered correctly
+# copy basket
+Atome.new({ renderers: [:html], id: :copy, collect: [], type: :group, tag: { system: true } })
 
-# use atome.atome to create a new atome using a more permissive syntax less performances but params must be formatted
-# and ordered correctly
 
-# Atome.atome ids the easiest way to  create a new atome
-# Atome.atome({
-#                      shape: { left: 0, right: 0, top: 0, bottom: 0, id: :view, color: { id: :c1, render: [:headless],
-# red: 0.15, green: 0.15, blue: 0.15, alpha: 1 } } })
+#machine
+Atome.new({ renderers: default_render, id: machine_id, type: :machine, password: machine_password,
+            name: :macAir, data: { date: '10090717' }, tag: { system: true } })
 
-# WARNING: when using Atome.new syntax , you must get your object using the .atome
-# example  to get the atome above : use a.shape.left and not a.left it wont access the physical object
-# initialize Universe
+#user
+human({ id: :anonymous, login: true, password: user_password, data: { birthday: '10/05/1996' },selection: [], tag: { system: true } , attach: :user_view })
+
+Universe.current_machine = machine_id
+# the constant A is used to access alla atomes methods
+A = Atome.new(
+  { renderers: default_render, id: :atome, type: :element, tag: { system: true } }
+)
+# atome infos
+def atome_infos
+  puts "atome version: #{Atome::VERSION}"
+  puts "device identity: #{Universe.app_identity}"
+  puts "application identity: #{Atome::aui}"
+  puts "host framework: #{Atome::host}"
+  puts "engine: #{Universe.engine}"
+  puts "users: #{Universe.users}"
+  puts "current user: #{Universe.current_user}"
+  puts "machine: #{Universe.current_machine}"
+  server = Universe.current_server
+  server ||= 'disconnected'
+  puts "server: #{server}"
+end
+
+atome_infos

data/lib/atome/helpers/color_helper/color/rgb/colors.rb

@@ -164,4 +164,4 @@ class Color::RGB
   named [0x9a, 0xcd, 0x32], :YellowGreen
 end
 
-require 'atome/helpers/color_helper/color/rgb/metallic'
+require_relative 'metallic'

data/lib/atome/helpers/color_helper/color/rgb.rb

@@ -712,4 +712,4 @@ class << Color::RGB
     end
   end
 end
-require 'atome/helpers/color_helper/color/rgb/colors'
+require_relative  'rgb/colors'

data/lib/atome/helpers/color_helper/color.rb

@@ -1,3 +1,4 @@
+# Old code
 # :title: Color -- Colour Management with Ruby
 # :main: README.rdoc
 
@@ -140,13 +141,18 @@ class << Color
 
   alias normalize_16bit normalize_word
 end
-
-require 'atome/helpers/color_helper/color/rgb'
-require 'atome/helpers/color_helper/color/cmyk'
-require 'atome/helpers/color_helper/color/grayscale'
-require 'atome/helpers/color_helper/color/hsl'
-require 'atome/helpers/color_helper/color/yiq'
-require 'atome/helpers/color_helper/color/css'
+require_relative 'color/rgb'
+require_relative 'color/cmyk'
+require_relative 'color/grayscale'
+require_relative 'color/hsl'
+require_relative 'color/yiq'
+require_relative 'color/css'
+# require 'atome/helpers/color_helper/color/rgb'
+# require 'atome/helpers/color_helper/color/cmyk'
+# require 'atome/helpers/color_helper/color/grayscale'
+# require 'atome/helpers/color_helper/color/hsl'
+# require 'atome/helpers/color_helper/color/yiq'
+# require 'atome/helpers/color_helper/color/css'
 
 class << Color
   def const_missing(name)
@@ -194,3 +200,216 @@ class << Color
     color.to_hsl
   end
 end
+
+
+######################################
+# new code:
+
+# # :title: Color -- Colour Management with Ruby
+# # :main: README.rdoc
+#
+# # = Colour Management with Ruby
+#
+# module Colour
+#   module Color
+#     COLOR_VERSION = '1.8'
+#
+#     class RGB; end
+#
+#     class CMYK; end
+#
+#     class HSL; end
+#
+#     class GrayScale; end
+#
+#     class YIQ; end
+#
+#     # The maximum "resolution" for colour math; if any value is less than or
+#     # equal to this value, it is treated as zero.
+#     COLOR_EPSILON = 1e-5
+#     # The tolerance for comparing the components of two colours. In general,
+#     # colours are considered equal if all of their components are within this
+#     # tolerance value of each other.
+#     COLOR_TOLERANCE = 1e-4
+#
+#     # Compares the +other+ colour to this one. The +other+ colour will be
+#     # coerced to the same type as the current colour. Such converted colour
+#     # comparisons will always be more approximate than non-converted
+#     # comparisons.
+#     #
+#     # If the +other+ colour cannot be coerced to the current colour class, a
+#     # +NoMethodError+ exception will be raised.
+#     #
+#     # All values are compared as floating-point values, so two colours will be
+#     # reported equivalent if all component values are within COLOR_TOLERANCE
+#     # of each other.
+#     def ==(other)
+#       Color.equivalent?(self, other)
+#     end
+#
+#     # The primary name for the colour.
+#     def name
+#       names.first
+#     end
+#
+#     # All names for the colour.
+#     def names
+#       self.names = nil unless defined? @names
+#       @names
+#     end
+#
+#     def names=(n)
+#       # :nodoc:
+#       @names = Array(n).flatten.compact.map(&:to_s).map(&:downcase).sort.uniq
+#     end
+#
+#     alias_method :name=, :names=
+#   end
+#
+#   class << Color
+#     # Returns +true+ if the value is less than COLOR_EPSILON.
+#     def near_zero?(value)
+#       (value.abs <= Color::COLOR_EPSILON)
+#     end
+#
+#     # Returns +true+ if the value is within COLOR_EPSILON of zero or less than
+#     # zero.
+#     def near_zero_or_less?(value)
+#       (value < 0.0 or near_zero?(value))
+#     end
+#
+#     # Returns +true+ if the value is within COLOR_EPSILON of one.
+#     def near_one?(value)
+#       near_zero?(value - 1.0)
+#     end
+#
+#     # Returns +true+ if the value is within COLOR_EPSILON of one or more than
+#     # one.
+#     def near_one_or_more?(value)
+#       (value > 1.0 or near_one?(value))
+#     end
+#
+#     # Returns +true+ if the two values provided are near each other.
+#     def near?(x, y)
+#       (x - y).abs <= Color::COLOR_TOLERANCE
+#     end
+#
+#     # Returns +true+ if the two colours are roughly equivalent. If colour
+#     # conversions are required, this all conversions will be implemented
+#     # using the default conversion mechanism.
+#     def equivalent?(a, b)
+#       return false unless a.kind_of?(Color) && b.kind_of?(Color)
+#       a.to_a.zip(a.coerce(b).to_a).all? { |(x, y)| near?(x, y) }
+#     end
+#
+#     # Coerces, if possible, the second given colour object to the first
+#     # given colour object type. This will probably involve colour
+#     # conversion and therefore a loss of fidelity.
+#     def coerce(a, b)
+#       a.coerce(b)
+#     end
+#
+#     # Normalizes the value to the range (0.0) .. (1.0).
+#     def normalize(value)
+#       if near_zero_or_less? value
+#         0.0
+#       elsif near_one_or_more? value
+#         1.0
+#       else
+#         value
+#       end
+#     end
+#
+#     alias normalize_fractional normalize
+#
+#     # Normalizes the value to the specified range.
+#     def normalize_to_range(value, range)
+#       range = (range.end..range.begin) if (range.end < range.begin)
+#
+#       if value <= range.begin
+#         range.begin
+#       elsif value >= range.end
+#         range.end
+#       else
+#         value
+#       end
+#     end
+#
+#     # Normalize the value to the range (0) .. (255).
+#     def normalize_byte(value)
+#       normalize_to_range(value, 0..255).to_i
+#     end
+#
+#     alias normalize_8bit normalize_byte
+#
+#     # Normalize the value to the range (0) .. (65535).
+#     def normalize_word(value)
+#       normalize_to_range(value, 0..65535).to_i
+#     end
+#
+#     alias normalize_16bit normalize_word
+#   end
+#
+#   require_relative 'color/rgb'
+#   require_relative 'color/cmyk'
+#   require_relative 'color/grayscale'
+#   require_relative 'color/hsl'
+#   require_relative 'color/yiq'
+#   require_relative 'color/css'
+#   # require 'atome/helpers/color_helper/color/rgb'
+#   # require 'atome/helpers/color_helper/color/cmyk'
+#   # require 'atome/helpers/color_helper/color/grayscale'
+#   # require 'atome/helpers/color_helper/color/hsl'
+#   # require 'atome/helpers/color_helper/color/yiq'
+#   # require 'atome/helpers/color_helper/color/css'
+#
+#   class << Color
+#     def const_missing(name)
+#       #:nodoc:
+#       case name
+#       when "VERSION", :VERSION, "COLOR_TOOLS_VERSION", :COLOR_TOOLS_VERSION
+#         warn "Color::#{name} has been deprecated. Use Color::COLOR_VERSION instead."
+#         Color::COLOR_VERSION
+#       else
+#         if Color::RGB.const_defined?(name)
+#           warn "Color::#{name} has been deprecated. Use Color::RGB::#{name} instead."
+#           Color::RGB.const_get(name)
+#         else
+#           super
+#         end
+#       end
+#     end
+#
+#     # Provides a thin veneer over the Color module to make it seem like this
+#     # is Color 0.1.0 (a class) and not Color 1.4 (a module). This
+#     # "constructor" will be removed in the future.
+#     #
+#     # mode = :hsl::   +values+ must be an array of [ hue deg, sat %, lum % ].
+#     #                 A Color::HSL object will be created.
+#     # mode = :rgb::   +values+ will either be an HTML-style colour string or
+#     #                 an array of [ red, green, blue ] (range 0 .. 255). A
+#     #                 Color::RGB object will be created.
+#     # mode = :cmyk::  +values+ must be an array of [ cyan %, magenta %, yellow
+#     #                 %, black % ]. A Color::CMYK object will be created.
+#
+#   end
+#
+#   def new(values, mode = :rgb)
+#     warn "Color.new has been deprecated. Use Color::#{mode.to_s.upcase}.new instead."
+#     color = case mode
+#             when :hsl
+#               Colour::Color::HSL.new(*values)
+#             when :rgb
+#               values = [values].flatten
+#               if values.size == 1
+#                 Colour::Color::RGB.from_html(*values)  # Modification ici
+#               else
+#                 Colour::Color::RGB.new(*values)  # Et ici
+#               end
+#             when :cmyk
+#               Colour::Color::CMYK.new(*values)  # Et ici
+#             end
+#     color.to_hsl
+#   end
+# end
+

data/lib/atome/helpers/essentials.rb

@@ -11,37 +11,33 @@ module Essentials
             <path d="M1679.33,410.731C1503.98,413.882 1402.52,565.418 1402.72,691.803C1402.91,818.107 1486.13,846.234 1498.35,1056.78C1501.76,1313.32 1173.12,1490.47 987.025,1492.89C257.861,1502.39 73.275,904.061 71.639,735.381C70.841,653.675 1.164,647.648 2.788,737.449C12.787,1291.4 456.109,1712.79 989.247,1706.24C1570.67,1699.09 1982.31,1234 1965.76,683.236C1961.3,534.95 1835.31,407.931 1679.33,410.731Z" style="fill:rgb(201,12,125);"/>
         </g>
     </g>
-STR
+  STR
+
   @default_params = {
     # Warning :  type must be define first
-    render_engines: [:browser],
-    # collector: { type: :element, attach: [:black_matter] },
-    image: { type: :image, attach: [:view] },
-    web: { type: :web, attach: [:view] },
-    video: { type: :video, attach: [:view] },
-    animation: { type: :animation,  attach: [:black_matter] },
-    element: { type: :element, renderers: [], attach: [:black_matter] },
-    matrix: { type: :shape, width: 99, height: 99,
-              attached: :matrix_color,
-              left: 100, top: 100, clones: [], preset: :matrix, attach: [:view] },
+    render_engines: [:html],
+    image: { type: :image },
+    # FIXME : look at build_atome FIXME to resolve default parent attachment problem
+    video: { type: :video },
+    animation: { type: :animation, attach: :black_matter },
+    element: { type: :element, renderers: [], attach: :black_matter },
     box: { type: :shape, width: 99, height: 99,
-           attached: :box_color, attach: [:view],
-           left: 100, top: 100, clones: [], preset: :box },
-    vector: { type: :shape, width: 99, height: 99,
-           attach: [:view],
-           left: 100, top: 100, clones: [], preset: :vector , definition: corp},
+           apply: [:box_color],
+           left: 100, top: 100,  preset: :box },
+    vector: { type: :vector, width: 99, height: 99,
+              left: 100, top: 100,  preset: :vector, definition: corp },
     circle: { type: :shape, width: 99, height: 99, smooth: '100%',
-              attached: :circle_color, attach: [:view],
-              left: 100, top: 100, clones: [], preset: :circle },
+              apply: [:circle_color],
+              left: 100, top: 100,  preset: :circle },
     shape: { type: :shape, width: 99, height: 99,
-             attached: :shape_color, attach: [:view],
-             left: 100, top: 100, clones: [] },
-    text: { type: :text, visual: { size: 25 },
-            attached: :text_color, attach: [:view],
-            data: 'this is a text sample', width: 199, height: 33, clones: [] },
-    drm: { type: :drm, attach: [:black_matter] },
-    shadow: { type: :shadow, attach: [:black_matter] },
-    color: {  type: :color,attach: [:black_matter], red: 0, green: 0, blue: 0, alpha: 1  }
+             apply: [:shape_color],
+             left: 100, top: 100 },
+    text: { type: :text, component: { size: 18 },
+            apply: [:text_color],
+            width: :auto, height: :auto },
+    drm: { type: :drm, attach: :black_matter },
+    shadow: { type: :shadow, red: 0, green: 0, blue: 0, alpha: 0 },
+    color: { type: :color, red: 0, green: 0, blue: 0, alpha: 1}
   }
 
   def self.default_params

data/lib/atome/helpers/security.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# extensions for security
+class Atome
+  def authorise(autorisations)
+    autorisations[:read]&.each do |k, v|
+      autorisations[:read][k] = Black_matter.encode(v)
+    end
+    autorisations[:write]&.each do |k, v|
+      autorisations[:write][k] = Black_matter.encode(v)
+    end
+
+    @authorisations = autorisations
+  end
+
+  def check_password_destruction(operation, element)
+    return unless @authorisations[:destroy]
+
+    @authorisations[operation].delete(element)
+  end
+
+  def write_auth(element)
+    if (@password && @password[:write]) && @authorisations && @authorisations[:write]
+      if !@authorisations[:write][element]
+        return false
+      elsif @password[:write][element] == @authorisations[:write][element]
+        # we check if we a specific password to read the particle
+        check_password_destruction(:write, element)
+        return true
+      elsif @authorisations[:write][:atome] == @password[:write][:atome]
+
+        puts "#{@authorisations[:write][:atome]} == #{@password[:write][:atome]}"
+        check_password_destruction(:write, element)
+        # we check if we a a password that allow to read the whole atome so all the particles
+        return true
+      else
+        check_password_destruction(:write, element)
+        return false
+      end
+
+      check_password_destruction(:write, element)
+    else
+      true
+    end
+  end
+
+  def read_auth(element)
+
+    if (@password && @password[:read]) && @authorisations && @authorisations[:read]
+      if !@authorisations[:read][element]
+        return false
+      elsif @password[:read][element] == @authorisations[:read][element]
+        check_password_destruction(:read, element)
+        # we check if we a specific password to read the particle
+        return true
+      elsif @authorisations[:read][:atome] == @password[:read][:atome]
+        check_password_destruction(:read, element)
+        # we check if we a a password that allow to read the whole atome so all the particles
+        return true
+      else
+        check_password_destruction(:read, element)
+
+        return false
+      end
+
+      check_password_destruction(:read, element)
+    else
+      true
+    end
+  end
+end