atome 0.4.7.0 → 0.5.1.1

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

@@ -0,0 +1,62 @@
+# A colour object representing YIQ (NTSC) colour encoding.
+class Color::YIQ
+  include Color
+
+  # Creates a YIQ colour object from fractional values 0 .. 1.
+  #
+  #   Color::YIQ.new(0.3, 0.2, 0.1)
+  def self.from_fraction(y = 0, i = 0, q = 0, &block)
+    new(y, i, q, 1.0, &block)
+  end
+
+  # Creates a YIQ colour object from percentages 0 .. 100.
+  #
+  #   Color::YIQ.new(10, 20, 30)
+  def initialize(y = 0, i = 0, q = 0, radix = 100.0, &block) # :yields self:
+    @y, @i, @q = [ y, i, q ].map { |v| Color.normalize(v / radix) }
+    block.call if block
+  end
+
+  def coerce(other)
+    other.to_yiq
+  end
+
+  def to_yiq
+    self
+  end
+
+  def brightness
+    @y
+  end
+  def to_grayscale
+    Color::GrayScale.new(@y)
+  end
+  alias to_greyscale to_grayscale
+
+  def y
+    @y
+  end
+  def y=(yy)
+    @y = Color.normalize(yy)
+  end
+  def i
+    @i
+  end
+  def i=(ii)
+    @i = Color.normalize(ii)
+  end
+  def q
+    @q
+  end
+  def q=(qq)
+    @q = Color.normalize(qq)
+  end
+
+  def inspect
+    "YIQ [%.2f%%, %.2f%%, %.2f%%]" % [ @y * 100, @i * 100, @q * 100 ]
+  end
+
+  def to_a
+    [ y, i, q ]
+  end
+end

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

@@ -0,0 +1,196 @@
+# :title: Color -- Colour Management with Ruby
+# :main: README.rdoc
+
+# = Colour Management with Ruby
+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 '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.
+  def new(values, mode = :rgb)
+    warn "Color.new has been deprecated. Use Color::#{mode.to_s.upcase}.new instead."
+    color = case mode
+            when :hsl
+              Color::HSL.new(*values)
+            when :rgb
+              values = [values].flatten
+              if values.size == 1
+                Color::RGB.from_html(*values)
+              else
+                Color::RGB.new(*values)
+              end
+            when :cmyk
+              Color::CMYK.new(*values)
+            end
+    color.to_hsl
+  end
+end

data/lib/atome/helpers/essentials.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# use to sanitize and secure user input
+module Essentials
+  @default_params = {
+    render_engines: [:browser],
+    element: { type: :element, renderers: [] },
+    box: { renderers: '', id: '', type: :shape, parents: [], children: [], width: 99, height: 99 },
+    circle: { renderers: '', id: '', type: :shape, parents: [], children: [], width: 99, height: 99, left: 12, top: 12,
+              smooth: '100%' },
+    shape: { renderers: '', id: '', width: 100, type: :shape, height: 100, left: 100, top: 100,
+             color: { left: 0, top: 0, z: 0, red: 0.1, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
+             generator: :manual },
+    text: { type: :text, parents: [:view], children: [], visual: { size: 25 },
+            data: 'this is a text sample', left: 300, top: 33, width: 199, height: 33 },
+    drm: { type: :drm },
+    shadow: {}
+  }
+
+  def self.default_params
+    @default_params
+  end
+
+  def self.new_default_params(new_default)
+    @default_params.merge!(new_default)
+  end
+
+  def validation(atome_instance_var)
+    # TODO: write validation scheme
+    true if atome_instance_var
+  end
+
+  def add_essential_drm(params)
+    essential_drm = { authorisation: { read: [Atome.current_user], write: [Atome.current_user] },
+                      atome: { read: [:all], write: [:me] } }
+    params[:drm] = if params[:drm]
+                     essential_drm.merge(params[:drm])
+                   else
+                     essential_drm
+                   end
+  end
+end

data/lib/atome/helpers/sanitizer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# atome sanitizer
+class Atome
+  private
+
+  def create_color_hash(params)
+    rgb_color = Color::CSS[params].css_rgb
+    split_data = rgb_color.sub('rgb(', '').sub(')', '').gsub(',', '').split('%')
+    { red: split_data[0].to_f / 100, green: split_data[1].to_f / 100, blue: split_data[2].to_f / 100 }
+  end
+
+  def found_parent_and_render
+    if @atome
+      parent_found = [@atome[:id]]
+      render_found = @atome[:renderers]
+    else
+      parent_found = []
+      render_found = Essentials.default_params[:render_engines]
+    end
+    { parent: parent_found, renderers: render_found }
+  end
+
+  def sanitize_element(params)
+    parent_found = found_parent_and_render[:parent]
+    render_found = found_parent_and_render[:renderers]
+    default_params = { renderers: render_found, id: "element_#{Universe.atomes.length}", type: :element,
+                       parents: parent_found }
+    default_params.merge!(params)
+  end
+
+  def sanitize_color(params)
+    parent_found = found_parent_and_render[:parent]
+    render_found = found_parent_and_render[: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
+
+end

data/lib/atome/helpers/utilities.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# toolbox   method here
+class Atome
+  private
+
+  def a_render
+    @atome.each do |element, value|
+      send(element, value) unless element == :type
+    end
+  end
+
+  def security_pass(_element, _value)
+    true
+  end
+
+  def particle_sanitizer(_element, params)
+    params
+  end
+
+  def atome_sanitizer(element, params)
+    send("sanitize_#{element}", params)
+  end
+
+  def sanitize_particle(element, value, &user_proc)
+    value = particle_sanitizer(element, value)
+    create_particle(element, value, &user_proc)
+  end
+
+  def identity_generator
+    { date: Time.now, location: geolocation }
+  end
+
+  def broadcasting(element, value)
+    return unless @broadcast[:particles]&.include?(element)
+
+    bloc_found = @broadcast[:bloc]
+    instance_exec(self, element, value, &bloc_found) if bloc_found.is_a?(Proc)
+  end
+
+  def history(property, value)
+    "historize : #{property} #{value}"
+  end
+
+  public
+
+  def monitor(params, &proc_monitoring)
+    params[:atomes].each do |atome_id|
+      grab(atome_id).instance_variable_set('@broadcast', { particles: params[:particles], bloc: proc_monitoring })
+    end
+  end
+
+  def <<(particle)
+    value = particle.value
+    real_atome[property] << value
+  end
+end

data/lib/atome/kernel/essentials.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Essentials method here
+class Atome
+  private
+
+  def rendering(element_to_render, content, &user_proc)
+    render_engines = @atome[:renderers]
+    render_engines.each do |render_engine|
+      send("#{render_engine}_#{element_to_render}", content, &user_proc)
+    end
+  end
+
+  def get(element)
+    @atome[element]
+  end
+
+  def value
+    @atome
+  end
+
+  def to_s
+    if @value
+      @result = @value.to_s
+    elsif @atome
+      @result = @atome.to_s
+    end
+    @result.to_s
+  end
+end

data/lib/atome/kernel/universe.rb

@@ -1,37 +1,86 @@
 # frozen_string_literal: true
 
-# all created atomes are listed here
+# universe method here
 class Universe
-  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
+  @atomes = {}
+  @atome_list = []
+  @particle_list = []
+  @renderer_list = %i[html browser headless server]
+  @optionals_methods = {}
 
-  def self.initialize
-    @atomes = {}
-  end
+  class << self
+    attr_reader :atomes, :renderer_list, :atome_list, :particle_list
 
-  def self.atomes_add(new_atome,atome_id)
-    new_atome.instance_variable_set('@id', atome_id)
-    @atomes[atome_id] = new_atome
-  end
+    def add_to_particle_list(particle = nil)
+      instance_variable_get('@particle_list').push(particle)
+    end
 
-  def self.change_atome_id(prev_id, new_id)
-    @atomes[new_id] = @atomes.delete(prev_id)
-  end
+    def add_optionals_methods(method_name, &method_proc)
+      # this method is used to add optional methods
+      instance_variable_get('@optionals_methods').merge!({ method_name => method_proc })
+    end
 
-  def self.delete(id)
-    @atomes.delete(id)
-  end
+    def get_optionals_methods(method_name)
+      # this method is used to add optional methods
+      instance_variable_get('@optionals_methods')[method_name]
+    end
 
-  class << self
-    attr_reader :atomes
-  end
+    def add_to_atome_list(atome)
+      instance_variable_get('@atome_list').push(atome)
+    end
+
+    def add_to_atomes(atome)
+      instance_variable_get('@atomes').merge!(atome)
+    end
+
+    def 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 : 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 change_atome_id(prev_id, new_id)
+      @atomes[new_id] = @atomes.delete(prev_id)
+    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 current_machine
+      platform = RUBY_PLATFORM.downcase
+      output = `#{platform =~ /win32/ ? 'ipconfig /all' : 'ifconfig'}`
+      current_machine_decision(platform, output)
+      # TODO: check the code above and create a sensible identity
+    end
+
+    def current_user
+      @user
+    end
+
+    def 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 self.connected
-    true
+    def connected
+      true
+    end
   end
 end

data/lib/atome/presets/atome.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# TODO: params shouldn't be merge but they must respect the order
+# TODO: Add default value for each methods below
+# TODO: Factorise codes below
+# TODO we must clarified/unified the usage of presets and sanitizer it is not clear
+
+# shaper creation
+class Atome
+  def atome_common(atome_type, generated_id, generated_render, generated_parents, params)
+    temp_default = Essentials.default_params[atome_type]
+    temp_default[:id] = generated_id
+    temp_default[:parents] = generated_parents
+    temp_default[:renderers] = generated_render
+    temp_default.merge(params)
+  end
+
+  def box(params = {}, &bloc)
+    default_renderer = Essentials.default_params[:render_engines]
+    atome_type = :box
+    generated_render = params[:renderers] || default_renderer
+    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)
+    color_generated = sanitize_color({ parents: [generated_id], red: 0.3, green: 0.3, blue: 0.3 })
+    params[:color] = color_generated
+    Atome.new({ atome_type => params }, &bloc)
+  end
+
+  def circle(params = {}, &bloc)
+    default_renderer = Essentials.default_params[:render_engines]
+    atome_type = :circle
+    generated_render = params[:renderers] || default_renderer
+    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)
+    color_generated = sanitize_color({ parents: [generated_id], red: 0.6, green: 0.6, blue: 0.6 })
+    params[:color] = color_generated
+    Atome.new({ atome_type => params }, &bloc)
+  end
+
+  def image(params = {}, &bloc)
+    default_renderer = Essentials.default_params[:render_engines]
+
+    generated_id = params[:id] || "image_#{Universe.atomes.length}"
+    generated_render = params[:renderers] || default_renderer
+    generated_parents = params[:parents] || id.value
+
+    temp_default = { renderers: generated_render, id: generated_id, type: :image, parents: [generated_parents],
+                     children: [], width: 99, height: 99, path: './medias/images/atome.svg' }
+    params = temp_default.merge(params)
+    Atome.new({ image: params }, &bloc)
+  end
+
+  def text(params = {}, &bloc)
+    default_renderer = Essentials.default_params[:render_engines]
+    atome_type = :text
+    generated_render = params[:renderers] || default_renderer
+    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)
+    color_generated = sanitize_color({ parents: [generated_id], red: 0.9, green: 0.9, blue: 0.9 })
+    params[:color] = color_generated
+    Atome.new({ atome_type => params }, &bloc)
+  end
+end

data/lib/atome/processors/utilities.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Atome processors
+class Atome
+  private
+
+  def data_code_processor(data)
+    eval data
+  end
+end