atome 0.4.7.0 → 0.5.1.4

data/lib/atome/genesis/generators/atome.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+generator = Genesis.generator
+
+generator.build_atome(:color)
+generator.build_sanitizer(:color) do |params|
+  parent_found = found_parents_and_renderers[:parent]
+  render_found = found_parents_and_renderers[:renderers]
+  default_params = { renderers: render_found, id: "color_#{Universe.atomes.length}", type: :color,
+                     parents: parent_found,
+                     red: 0, green: 0, blue: 0, alpha: 1 }
+  params = create_color_hash(params) unless params.instance_of? Hash
+  default_params.merge!(params)
+end
+
+generator.build_sanitizer(:video) do |params|
+  parent_found = found_parents_and_renderers[:parent]
+  render_found = found_parents_and_renderers[:renderers]
+  default_params = { renderers: render_found, id: "video_#{Universe.atomes.length}", type: :video,
+                     parents: parent_found }
+  default_params.merge!(params)
+end
+generator.build_atome(:shadow)
+generator.build_atome(:shape)
+generator.build_atome(:text)
+generator.build_atome(:image)
+generator.build_atome(:video)
+generator.build_atome(:code)
+generator.build_atome(:audio)
+generator.build_atome(:element)
+generator.build_atome(:web)
+generator.build_sanitizer(:element) do |params|
+  parent_found = found_parents_and_renderers[:parent]
+  render_found = []
+  default_params = { renderers: render_found, id: "element_#{Universe.atomes.length}", type: :element,
+                     parents: parent_found }
+  default_params.merge!(params)
+end

data/lib/atome/{renderers/headless/properties/generator.rb → genesis/generators/communication.rb}

@@ -1 +1,3 @@
 # frozen_string_literal: true
+
+generator = Genesis.generator

data/lib/atome/genesis/generators/effect.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+generator = Genesis.generator
+
+generator.build_particle(:smooth)
+generator.build_particle(:blur)

data/lib/atome/genesis/generators/event.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+generator = Genesis.generator
+
+generator.build_particle(:touch)
+generator.build_particle(:play)
+generator.build_particle(:time)
+generator.build_particle(:pause)
+generator.build_particle(:on)
+generator.build_particle(:fullscreen)

data/lib/atome/genesis/generators/geometry.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+generator = Genesis.generator
+
+generator.build_particle(:width)
+generator.build_particle(:height)

data/lib/atome/genesis/generators/identity.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+generator = Genesis.generator
+
+generator.build_particle(:type)
+generator.build_particle(:parents)
+generator.build_particle(:children)
+generator.build_particle(:link) do |child_id|
+  child_found = grab(child_id)
+  child_found.atome[:parents] << @atome[:id]
+  child_found.refresh
+end
+
+generator.build_particle(:id)
+generator.build_sanitizer(:id) do |params|
+  if @atome[:id] != params
+    Universe.update_atome_id(params, self, @atome[:id])
+  else
+    Universe.add_to_atomes(params, self)
+  end
+  params
+end
+
+generator.build_option(:pre_render_parents) do |parents_id_found|
+  parents_id_found.each do |parents_id|
+    parents_found = grab(parents_id)
+    parents_found.children << id if parents_found
+  end
+end

data/lib/atome/genesis/generators/material.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+generator = Genesis.generator
+
+generator.build_particle(:red)
+generator.build_particle(:green)
+generator.build_particle(:blue)
+generator.build_particle(:alpha)
+generator.build_particle(:visual)
+generator.build_particle(:overflow)

data/lib/atome/genesis/generators/spatial.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+generator = Genesis.generator
+# create particles
+generator.build_particle(:left) do |_params, user_proc|
+  instance_exec(&user_proc) if user_proc.is_a?(Proc)
+end
+
+generator.build_particle(:right)
+generator.build_particle(:top)
+generator.build_particle(:bottom)
+generator.build_particle(:rotate)
+generator.build_particle(:direction)

data/lib/atome/genesis/generators/utility.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+generator = Genesis.generator
+
+generator.build_particle(:renderers)
+generator.build_particle(:code)
+generator.build_particle(:run) do |params|
+  code_found = @atome[:code]
+  instance_exec(params, &code_found) if code_found.is_a?(Proc)
+end
+generator.build_particle(:broadcast)
+generator.build_particle(:additional)
+generator.build_particle(:data)
+generator.build_particle(:delete) do
+  Universe.delete(@atome[:id])
+end
+generator.build_particle(:clear)
+generator.build_particle(:path)
+generator.build_particle(:schedule) do |date, proc|
+  date = date.to_s
+  delimiters = [',', ' ', ':', '-']
+  format_date = date.split(Regexp.union(delimiters))
+  Universe.renderer_list.each do |renderer|
+    send("#{renderer}_schedule", format_date, &proc)
+  end
+end
+generator.build_particle(:read) do |file, proc|
+  Universe.renderer_list.each do |renderer|
+    send("#{renderer}_reader", file, &proc)
+  end
+end

data/lib/atome/genesis/genesis.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# allow to access Atome class using only a uniq atome
+class Genesis
+  class << self
+    def generator
+      Atome.new
+    end
+  end
+end
+
+# Genesis method here
+class Atome
+  def build_particle(particle_name, &particle_proc)
+    # we add the new method to the particle's collection of methods
+    Universe.add_to_particle_list(particle_name)
+    auto_render_generator(particle_name)
+    new_particle(particle_name, &particle_proc)
+    additional_particle_methods(particle_name, &particle_proc)
+  end
+
+  def build_atome(atome_name, &atome_proc)
+    # we add the new method to the atome's collection of methods
+    Universe.add_to_atome_list(atome_name)
+    auto_render_generator(atome_name)
+    new_atome(atome_name, &atome_proc)
+  end
+
+  def auto_render_generator(element)
+    Universe.renderer_list.each do |render_engine|
+      build_render_method("#{render_engine}_#{element}")
+    end
+  end
+
+  def build_render_method(renderer_name, &method_proc)
+    new_render_engine(renderer_name, &method_proc)
+  end
+
+  def build_sanitizer(method_name, &method_proc)
+    Universe.add_sanitizer_method(method_name.to_sym, &method_proc)
+  end
+
+  def build_option(method_name, &method_proc)
+    Universe.add_optional_method(method_name.to_sym, &method_proc)
+  end
+end

data/lib/atome/genesis/sparkle.rb

@@ -0,0 +1,58 @@
+# 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]
+
+Universe.current_user = :jeezs
+puts "application identity: #{Universe.app_identity}"
+puts "atome version: #{Atome::VERSION}"
+puts "current host: #{Universe.current_machine}"
+puts "current user: #{Universe.current_user}"
+
+Atome.new(
+  { element: { renderers: [], id: :eDen, type: :element,
+               parents: [], children: [] } }
+)
+
+Atome.new(
+  { element: { renderers: [], id: :user_view, type: :element,
+               parents: [:eDen], children: [] } }
+)
+
+Atome.new(
+  { shape: { renderers: default_render, id: :view, type: :shape, parents: [:user_view], children: [],
+             left: 0, right: 0, top: 0, bottom: 0, overflow: :auto,
+             color: { renderers: default_render, id: :view_color, type: :color, parents: [:view],
+                      red: 0.15, green: 0.15, blue: 0.15, alpha: 1 } } }
+)
+
+# init basic object for atome environment
+
+# Atome.new is used  to create a new atome using best performances but params must be formatted and ordered correctly
+
+# 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 } } })
+
+# 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

data/lib/atome/helpers/callbacks.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+#  callbacks methods here
+class Atome
+  def schedule_callback(proc)
+    instance_exec(&proc) if proc.is_a?(Proc)
+  end
+
+  def read_callback(file, proc)
+    instance_exec(file, &proc) if proc.is_a?(Proc)
+  end
+end

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

@@ -0,0 +1,263 @@
+# An CMYK colour object. CMYK (cyan, magenta, yellow, and black) colours are
+# based on additive percentages of ink. A CMYK colour of (0.3, 0, 0.8, 0.3)
+# would be mixed from 30% cyan, 0% magenta, 80% yellow, and 30% black.
+# Primarily used in four-colour printing processes.
+class Color::CMYK
+  include Color
+
+  # The format of a DeviceCMYK colour for PDF. In color-tools 2.0 this will
+  # be removed from this package and added back as a modification by the
+  # PDF::Writer package.
+  PDF_FORMAT_STR = "%.3f %.3f %.3f %.3f %s"
+
+  # Coerces the other Color object into CMYK.
+  def coerce(other)
+    other.to_cmyk
+  end
+
+  class << self
+    # Creates a CMYK colour object from fractional values 0..1.
+    #
+    #   Color::CMYK.from_fraction(0.3, 0, 0.8, 0.3)
+    def from_fraction(c = 0, m = 0, y = 0, k = 0, &block)
+      new(c, m, y, k, 1.0, &block)
+    end
+
+    # Creates a CMYK colour object from percentages. Internally, the colour is
+    # managed as fractional values 0..1.
+    #
+    #   Color::CMYK.new(30, 0, 80, 30)
+    def from_percent(c = 0, m = 0, y = 0, k = 0, &block)
+      new(c, m, y, k, &block)
+    end
+  end
+
+  # Creates a CMYK colour object from percentages. Internally, the colour is
+  # managed as fractional values 0..1.
+  #
+  #   Color::CMYK.new(30, 0, 80, 30)
+  def initialize(c = 0, m = 0, y = 0, k = 0, radix = 100.0, &block) # :yields self:
+    @c, @m, @y, @k = [ c, m, y, k ].map { |v| Color.normalize(v / radix) }
+    block.call(self) if block
+  end
+
+  # Present the colour as a DeviceCMYK fill colour string for PDF. This will
+  # be removed from the default package in color-tools 2.0.
+  def pdf_fill
+    PDF_FORMAT_STR % [ @c, @m, @y, @k, "k" ]
+  end
+
+  # Present the colour as a DeviceCMYK stroke colour string for PDF. This
+  # will be removed from the default package in color-tools 2.0.
+  def pdf_stroke
+    PDF_FORMAT_STR % [ @c, @m, @y, @k, "K" ]
+  end
+
+  # Present the colour as an RGB HTML/CSS colour string (e.g., "#aabbcc").
+  # Note that this will perform a #to_rgb operation using the default
+  # conversion formula.
+  def html
+    to_rgb.html
+  end
+
+  # Present the colour as an RGB HTML/CSS colour string (e.g., "rgb(0%, 50%,
+  # 100%)"). Note that this will perform a #to_rgb operation using the
+  # default conversion formula.
+  def css_rgb
+    to_rgb.css_rgb
+  end
+
+  # Present the colour as an RGBA (with alpha) HTML/CSS colour string (e.g.,
+  # "rgb(0%, 50%, 100%, 1)"). Note that this will perform a #to_rgb
+  # operation using the default conversion formula.
+  def css_rgba(alpha = 1)
+    to_rgb.css_rgba(alpha)
+  end
+
+  # Present the colour as an HSL HTML/CSS colour string (e.g., "hsl(180,
+  # 25%, 35%)"). Note that this will perform a #to_hsl operation using the
+  # default conversion formula.
+  def css_hsl
+    to_hsl.css_hsl
+  end
+
+  # Present the colour as an HSLA (with alpha) HTML/CSS colour string (e.g.,
+  # "hsla(180, 25%, 35%, 1)"). Note that this will perform a #to_hsl
+  # operation using the default conversion formula.
+  def css_hsla
+    to_hsl.css_hsla
+  end
+
+  # Converts the CMYK colour to RGB. Most colour experts strongly suggest
+  # that this is not a good idea (some even suggesting that it's a very bad
+  # idea). CMYK represents additive percentages of inks on white paper,
+  # whereas RGB represents mixed colour intensities on a black screen.
+  #
+  # However, the colour conversion can be done, and there are two different
+  # methods for the conversion that provide slightly different results.
+  # Adobe PDF conversions are done with the first form.
+  #
+  #     # Adobe PDF Display Formula
+  #   r = 1.0 - min(1.0, c + k)
+  #   g = 1.0 - min(1.0, m + k)
+  #   b = 1.0 - min(1.0, y + k)
+  #
+  #     # Other
+  #   r = 1.0 - (c * (1.0 - k) + k)
+  #   g = 1.0 - (m * (1.0 - k) + k)
+  #   b = 1.0 - (y * (1.0 - k) + k)
+  #
+  # If we have a CMYK colour of [33% 66% 83% 25%], the first method will
+  # give an approximate RGB colour of (107, 23, 0) or #6b1700. The second
+  # method will give an approximate RGB colour of (128, 65, 33) or #804121.
+  # Which is correct? Although the colours may seem to be drastically
+  # different in the RGB colour space, they are very similar colours,
+  # differing mostly in intensity. The first is a darker, slightly redder
+  # brown; the second is a lighter brown.
+  #
+  # Because of this subtlety, both methods are now offered for conversion.
+  # The Adobe method is not used by default; to enable it, pass +true+ to
+  # #to_rgb.
+  #
+  # Future versions of Color may offer other conversion mechanisms that
+  # offer greater colour fidelity, including recognition of ICC colour
+  # profiles.
+  def to_rgb(use_adobe_method = false)
+    if use_adobe_method
+      Color::RGB.from_fraction(*adobe_cmyk_rgb)
+    else
+      Color::RGB.from_fraction(*standard_cmyk_rgb)
+    end
+  end
+
+  # Converts the CMYK colour to a single greyscale value. There are
+  # undoubtedly multiple methods for this conversion, but only a minor
+  # variant of the Adobe conversion method will be used:
+  #
+  #   g = 1.0 - min(1.0, 0.299 * c + 0.587 * m + 0.114 * y + k)
+  #
+  # This treats the CMY values similarly to YIQ (NTSC) values and then adds
+  # the level of black. This is a variant of the Adobe version because it
+  # uses the more precise YIQ (NTSC) conversion values for Y (intensity)
+  # rather than the approximates provided by Adobe (0.3, 0.59, and 0.11).
+  def to_grayscale
+    c = 0.299 * @c.to_f
+    m = 0.587 * @m.to_f
+    y = 0.114 * @y.to_f
+    g = 1.0 - [1.0, c + m + y + @k].min
+    Color::GrayScale.from_fraction(g)
+  end
+  alias to_greyscale to_grayscale
+
+  def to_cmyk
+    self
+  end
+
+  def inspect
+    "CMYK [%.2f%%, %.2f%%, %.2f%%, %.2f%%]" % [ cyan, magenta, yellow, black ]
+  end
+
+  # Converts to RGB then YIQ.
+  def to_yiq
+    to_rgb.to_yiq
+  end
+
+  # Converts to RGB then HSL.
+  def to_hsl
+    to_rgb.to_hsl
+  end
+
+  # Returns the cyan (C) component of the CMYK colour as a percentage value.
+  def cyan
+    @c * 100.0
+  end
+  # Returns the cyan (C) component of the CMYK colour as a value in the
+  # range 0.0 .. 1.0.
+  def c
+    @c
+  end
+  # Sets the cyan (C) component of the CMYK colour as a percentage value.
+  def cyan=(cc)
+    @c = Color.normalize(cc / 100.0)
+  end
+  # Sets the cyan (C) component of the CMYK colour as a value in the range
+  # 0.0 .. 1.0.
+  def c=(cc)
+    @c = Color.normalize(cc)
+  end
+
+  # Returns the magenta (M) component of the CMYK colour as a percentage
+  # value.
+  def magenta
+    @m * 100.0
+  end
+  # Returns the magenta (M) component of the CMYK colour as a value in the
+  # range 0.0 .. 1.0.
+  def m
+    @m
+  end
+  # Sets the magenta (M) component of the CMYK colour as a percentage value.
+  def magenta=(mm)
+    @m = Color.normalize(mm / 100.0)
+  end
+  # Sets the magenta (M) component of the CMYK colour as a value in the
+  # range 0.0 .. 1.0.
+  def m=(mm)
+    @m = Color.normalize(mm)
+  end
+
+  # Returns the yellow (Y) component of the CMYK colour as a percentage
+  # value.
+  def yellow
+    @y * 100.0
+  end
+  # Returns the yellow (Y) component of the CMYK colour as a value in the
+  # range 0.0 .. 1.0.
+  def y
+    @y
+  end
+  # Sets the yellow (Y) component of the CMYK colour as a percentage value.
+  def yellow=(yy)
+    @y = Color.normalize(yy / 100.0)
+  end
+  # Sets the yellow (Y) component of the CMYK colour as a value in the range
+  # 0.0 .. 1.0.
+  def y=(kk)
+    @y = Color.normalize(kk)
+  end
+
+  # Returns the black (K) component of the CMYK colour as a percentage
+  # value.
+  def black
+    @k * 100.0
+  end
+  # Returns the black (K) component of the CMYK colour as a value in the
+  # range 0.0 .. 1.0.
+  def k
+    @k
+  end
+  # Sets the black (K) component of the CMYK colour as a percentage value.
+  def black=(kk)
+    @k = Color.normalize(kk / 100.0)
+  end
+  # Sets the black (K) component of the CMYK colour as a value in the range
+  # 0.0 .. 1.0.
+  def k=(kk)
+    @k = Color.normalize(kk)
+  end
+
+  def to_a
+    [ c, m, y, k ]
+  end
+
+  private
+  # Implements the Adobe PDF conversion of CMYK to RGB.
+  def adobe_cmyk_rgb
+    [ @c, @m, @y ].map { |v| 1.0 - [ 1.0, v + @k ].min }
+  end
+
+  # Implements the standard conversion of CMYK to RGB.
+  def standard_cmyk_rgb
+    [ @c, @m, @y ].map { |v| 1.0 - (v * (1.0 - k) + k) }
+  end
+end

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

@@ -0,0 +1,7 @@
+# This namespace contains some CSS colour names.
+module Color::CSS
+  # Returns the RGB colour for name or +nil+ if the name is not valid.
+  def self.[](name)
+    Color::RGB.by_name(name) { nil }
+  end
+end