atome 0.5.2.7 → 0.5.3.2

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

@@ -2,11 +2,26 @@
 
 generator = Genesis.generator
 
-generator.build_particle(:red)
-generator.build_particle(:green)
-generator.build_particle(:blue)
-generator.build_particle(:alpha)
-generator.build_particle(:diffusion)
+generator.build_particle(:red) do
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
+end
+generator.build_particle(:green) do
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
+end
+generator.build_particle(:blue) do
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
+end
+generator.build_particle(:alpha) do
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
+end
+generator.build_particle(:diffusion) do
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
+end
 generator.build_particle(:visual)
 generator.build_particle(:overflow)
 generator.build_particle(:edit)

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

@@ -2,4 +2,4 @@
 
 generator = Genesis.generator
 # create particles
-generator.build_particle(:markers, :hash)
+generator.build_particle(:markers, { type: :hash })

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

@@ -11,6 +11,25 @@ end
 generator.build_particle(:broadcast)
 generator.build_particle(:additional)
 generator.build_particle(:data)
+# generator.build_particle(:delete) do |params|
+#   if params == true
+#     # the machine delete the current atome
+#     Universe.delete(@atome[:id])
+#   elsif params[:id]
+#     # the machine try to an atome by it's ID and delete it
+#     grab(params[:id]).delete(true)
+#   elsif instance_of? Hash
+#     # the machine try to find the sub particle id and remove it eg a.delete(monitor: :my_monitor) remove the monitor
+#     # with id my_monitor
+#     params.each do |param, value|
+#       atome[param][value] = nil
+#     end
+#   else
+#     # the machine try to reset the current particle(params), eg a.delete(:left) => left: 0
+#     send(params,0)
+#   end
+# end
+
 generator.build_particle(:delete) do |params|
   if params == true
     # the machine delete the current atome
@@ -18,17 +37,18 @@ generator.build_particle(:delete) do |params|
   elsif params[:id]
     # the machine try to an atome by it's ID and delete it
     grab(params[:id]).delete(true)
-  elsif instance_of? Hash
+  elsif params.instance_of? Hash
     # the machine try to find the sub particle id and remove it eg a.delete(monitor: :my_monitor) remove the monitor
     # with id my_monitor
     params.each do |param, value|
       atome[param][value] = nil
     end
   else
-    # the machine try to reset the current particle(params), eg a.delete(:left) => left: 0
+    #   # the machine try to reset the current particle(params), eg a.delete(:left) => left: 0
     send(params,0)
   end
 end
+
 generator.build_particle(:clear)
 generator.build_particle(:path)
 generator.build_particle(:schedule) do |date, proc|
@@ -47,3 +67,7 @@ end
 
 generator.build_particle(:cursor)
 
+generator.build_particle(:preset)
+
+generator.build_particle(:relations, { type: :hash })
+

data/lib/atome/genesis/genesis.rb

@@ -11,14 +11,22 @@ end
 
 # Genesis method here
 class Atome
-  def build_particle(particle_name,type=:string, &particle_proc)
+  def build_particle(particle_name,options={},&particle_proc)
+    type = options[:type]
+    type = :string if options[:type].nil?
+    store = options[:store]
+    store = true if options[:store].nil?
+    render = options[:render]
+    render = true if options[:render].nil?
+
     # we add the new method to the particle's collection of methods
     Universe.add_to_particle_list(particle_name, type)
-    auto_render_generator(particle_name)
-    new_particle(particle_name, &particle_proc)
-    additional_particle_methods(particle_name, &particle_proc)
+    auto_render_generator(particle_name) if render #  automatise the creation of an empty render method for current particle
+    new_particle(particle_name,store,render , &particle_proc)
+    additional_particle_methods(particle_name, store,render ,&particle_proc) # create alternative methods such as create 'method='
   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)

data/lib/atome/genesis/sparkle.rb

@@ -23,6 +23,7 @@ puts "application identity: #{Universe.app_identity}"
 puts "atome version: #{Atome::VERSION}"
 puts "current host: #{Universe.current_machine}"
 puts "current user: #{Universe.current_user}"
+puts "current server: #{Universe.current_server}"
 
 Atome.new(
   { element: { renderers: [], id: :eDen, type: :element,
@@ -34,11 +35,43 @@ Atome.new(
                parents: [:eDen], children: [] } }
 )
 
+# color creation
+Atome.new(
+  { color: { renderers: default_render, id: :view_color, type: :color,
+             red:  0.15, green: 0.15, blue: 0.15, alpha: 1 } }
+)
+
+Atome.new(
+  { color: { renderers: default_render, id: :shape_color, type: :color,
+             red: 0.4, green: 0.4, blue: 0.4, alpha: 1 } }
+)
+
+Atome.new(
+  { color: { renderers: default_render, id: :box_color, type: :color,
+             red: 0.5, green: 0.5, blue: 0.5, alpha: 1 } }
+)
+
+Atome.new(
+  { color: { renderers: default_render, id: :text_color, type: :color,
+             red: 0.3, green: 0.3, blue: 0.3, alpha: 1 } }
+)
+
+Atome.new(
+  { color: { renderers: default_render, id: :circle_color, type: :color,
+             red: 0.6, green: 0.6, blue: 0.6, alpha: 1 } }
+)
+
+Atome.new(
+  { color: { renderers: default_render, id: :matrix_color, type: :color,
+             left: 0, top: 0, red: 0.7, green: 0.7, blue: 0.7, alpha: 1, diffusion: :linear } }
+)
+
+# view creation
 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, attach: [:view],
-                      red: 0.15, green: 0.15, blue: 0.15, alpha: 1 } } }
+             attached: [:view_color], left: 0, right: 0, top: 0, bottom: 0, width: :auto, height: :auto, overflow: :auto
+  }
+  }
 )
 
 # init basic object for atome environment

data/lib/atome/helpers/essentials.rb

@@ -4,22 +4,31 @@
 module Essentials
   @default_params = {
     render_engines: [:browser],
-    animation: { type: :animation },
-    element: { type: :element, renderers: [] },
-    box: { renderers: '', id: '', type: :shape, parents: [], children: [], width: 99, height: 99,
-           color: { left: 0, top: 0,  red: 0.1, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
-           left: 100, top: 100 },
-    circle: { renderers: '', id: '', type: :shape, parents: [], children: [], width: 99, height: 99,
-              color: { left: 0, top: 0, red: 0.1, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
-              left: 100, top: 100, smooth: '100%' },
-    shape: { renderers: '', id: '', width: 100, type: :shape, height: 100, left: 100, top: 100,
-             color: { left: 0, top: 0, red: 0.1, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
-             generator: :manual },
-    text: { renderers: '', id: '',type: :text, parents: [:view], children: [], visual: { size: 25 },
-            color: { left: 0, top: 0, red: 0.3, green: 0.3, blue: 0.3, alpha: 1, diffusion: :linear },
-            data: 'this is a text sample', width: 199, height: 33 },
+    animation: { type: :animation, children: [] },
+    element: { type: :element, renderers: [], children: [] },
+    matrix: { renderers: [], id: '', type: :shape, parents: [], width: 99, height: 99,
+              attached: [:matrix_color], children: [],
+              # color: { left: 0, top: 0,  red: 0.1, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
+              left: 100, top: 100, clones: [], preset: :matrix },
+    box: { renderers: [], id: '', type: :shape, parents: [], width: 99, height: 99,
+           attached: [:box_color], children: [],
+           # color: { left: 0, top: 0,  red: 1, green: 0.3, blue: 0.3, alpha: 1, diffusion: :linear },
+           left: 100, top: 100, clones: [], preset: :box },
+    circle: { renderers: [], id: '', type: :shape, parents: [], width: 99, height: 99, smooth: '100%',
+              # color: { left: 0, top: 0,  red: 0.3, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
+              attached: [:circle_color], children: [],
+              left: 100, top: 100, clones: [], preset: :circle },
+    shape: { renderers: [], id: '', type: :shape, parents: [], width: 99, height: 99,
+             attached: [:view_color], children: [],
+             # color: { left: 0, top: 0,  red: 0.6, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
+             left: 100, top: 100, clones: [] },
+    text: { renderers: [], id: '', type: :text, parents: [:view], visual: { size: 25 },
+            attached: [:text_color], children: [],
+            # color: { left: 0, top: 0, red: 0.3, green: 0.3, blue: 0.3, alpha: 1, diffusion: :linear },
+            data: 'this is a text sample', width: 199, height: 33, clones: [] },
     drm: { type: :drm },
-    shadow: {}
+    shadow: {},
+    color: {}
   }
 
   def self.default_params

data/lib/atome/helpers/utilities.rb

@@ -28,11 +28,12 @@ class Atome
     "historize : #{property} #{value}"
   end
 
-  def broadcasting(altered_particle, value)
+  def broadcasting(element)
+    params=instance_variable_get("@#{element}")
     @broadcast.each_value do |particle_monitored|
-      if particle_monitored[:particles].include?(altered_particle)
+      if particle_monitored[:particles].include?(element)
         code_found=particle_monitored[:code]
-        instance_exec(self, altered_particle, value, &code_found) if code_found.is_a?(Proc)
+        instance_exec(self, element, params, &code_found) if code_found.is_a?(Proc)
       end
     end
   end
@@ -100,4 +101,42 @@ class Atome
   def refresh
     collapse
   end
+
+  def collector(params = {}, &bloc)
+    atome_type = :collector
+    generated_render = params[:renderers] || []
+    generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
+    generated_parents = params[:parents] || [id.value]
+    generated_children = params[:children] || []
+    params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
+    Batch.new({ atome_type => params }, &bloc)
+  end
+
+  def each(&proc)
+    value.each do |val|
+      instance_exec(val, &proc) if proc.is_a?(Proc)
+    end
+  end
+
+  def [](range)
+    if value[range].class == Atome
+      return value[range]
+    elsif value[range].class == Array
+      collector_object = Object.collector({})
+      collected_atomes = []
+      value[range].each do |atome_found|
+        collected_atomes << atome_found
+      end
+      collector_object.data(collected_atomes)
+
+      return collector_object
+    end
+
+  end
+
+  def set(params)
+    params.each do |particle, value|
+      send(particle, value)
+    end
+  end
 end

data/lib/atome/kernel/batch.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Batch
+
+  def each(&proc)
+    value.each do |val|
+      instance_exec(val, &proc) if proc.is_a?(Proc)
+    end
+  end
+
+  def id(val = nil)
+    if val
+      @id = val
+    else
+      @id
+    end
+  end
+
+  def initialize(params)
+    @id = params[:id] || "batch_#{Universe.atomes.length}"
+    Universe.add_to_atomes(@id, self)
+  end
+
+  def dispatch (method, *args, &block)
+    @data.each do |atome_found|
+      atome_found.send(method, *args, &block)
+    end
+  end
+
+  # TODO:  automatise collector methods creation when creato,g a new atome type
+  def color(args, &block)
+
+    dispatch(:color, args, &block)
+  end
+
+  def shadow(args, &block)
+    dispatch(:color, args, &block)
+  end
+
+  def method_missing(method, *args, &block)
+    dispatch(method, args, &block)
+  end
+
+  def data(collection)
+    @data = collection
+  end
+
+end

data/lib/atome/kernel/universe.rb

@@ -86,6 +86,10 @@ class Universe
       @user
     end
 
+    def current_server
+      `window.location.href` if RUBY_ENGINE.downcase == 'opal'
+    end
+
     def current_user=(user)
       # TODO: create or load an existing user
       # if user needs to be create the current_user will be eVe

data/lib/atome/presets/atome.rb

@@ -7,22 +7,34 @@
 
 # shaper creation
 class Atome
-  def atome_common(atome_type, generated_id, generated_render, generated_parents, params)
+  def atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
     temp_default = Essentials.default_params[atome_type] || {}
     temp_default[:id] = generated_id
     temp_default[:parents] = generated_parents
     temp_default[:clones] = []
     temp_default[:renderers] = generated_render
+    temp_default[:children] = generated_children.concat(temp_default[:children])
     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)
+    generated_children = params[:children] || []
+
+    params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
+
+    # params2 =  { renderers: [:browser], id: generated_id, type: :shape, parents: [generated_parents], children: [],
+    #              width: 99, height: 99,
+    #              color: { renderers: [:browser], id: "#{params[:id]}_color", type: :color, attach: [params[:id]],
+    #                       red: 0.15, green: 0.30, blue: 0.6, alpha: 1 },
+    #              left: 100, top: 100, clones: [], preset: :box
+    # }
+    # params[:children]=[]
     Atome.new({ atome_type => params }, &bloc)
   end
 
@@ -32,7 +44,8 @@ class Atome
     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)
+    generated_children = params[:children] || []
+    params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
     Atome.new({ atome_type => params }, &bloc)
   end
 
@@ -54,7 +67,8 @@ class Atome
     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)
+    generated_children = params[:children] || []
+    params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
     Atome.new({ atome_type => params }, &bloc)
   end
 
@@ -63,7 +77,8 @@ class Atome
     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)
+    generated_children = params[:children] || []
+    params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
     Atome.new({ atome_type => params }, &bloc)
   end
 
@@ -86,7 +101,8 @@ class Atome
     generated_render = params[:renderers] || default_renderer
     generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
     generated_parents = params[:parents] || []
-    params = atome_common(atome_type, generated_id, generated_render, generated_parents, params)
+    generated_children = params[:children] || []
+    params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
     Atome.new({ atome_type => params }, &bloc)
   end
 end

data/lib/atome/renderers/browser/atome.rb

@@ -6,8 +6,6 @@ DOM = :nil
 
 def parents(_val) end
 
-# end dummy code
-
 generator = Genesis.generator
 
 generator.build_render(:browser_shape) do
@@ -77,7 +75,7 @@ generator.build_render(:browser_text) do |_value, _user_proc|
 end
 
 generator.build_render(:browser_web) do
-  @browser_type = :web
+  @browser_type = :div
   id_found = @atome[:id]
   DOM do
     iframe({ id: id_found }).atome

data/lib/atome/renderers/browser/browser.rb

@@ -23,7 +23,20 @@ require 'atome/renderers/browser/helpers/video_helper'
 require 'atome/renderers/browser/helpers/web_helper'
 
 class Atome
-  attr_accessor 'browser_object'
+  attr_accessor :browser_object
+
+  def to_px
+    id_found = real_atome[:id]
+    property_found=property
+    value_get = ''
+    `
+      div = document.getElementById(#{id_found});
+      var style = window.getComputedStyle(div);
+      var original_value = style.getPropertyValue(#{property_found});
+      #{value_get}= parseInt(original_value);
+    `
+    value_get
+  end
 end
 
 def atome_js

data/lib/atome/renderers/browser/geometry.rb

@@ -3,9 +3,17 @@
 generator = Genesis.generator
 
 generator.build_render(:browser_width) do |value|
-  @browser_object.style[:width] = "#{value}px"
+  @browser_object.style[:width] = if value.instance_of? String
+                                    value
+                                  else
+                                    "#{value}px"
+                                  end
 end
 
 generator.build_render(:browser_height) do |value|
-  @browser_object.style[:height] = "#{value}px"
+  @browser_object.style[:height] = if value.instance_of? String
+                                     value
+                                   else
+                                     "#{value}px"
+                                   end
 end

data/lib/atome/renderers/browser/helpers/video_helper.rb

@@ -24,7 +24,7 @@ module BrowserHelper
   end
 
   def self.browser_play_video(_value, browser_object_found, atome_hash, atome_object, proc)
-    markers = atome_hash[:markers]
+    markers = atome_hash[:markers] ||= {}
     markers.each_value do |value|
       value[:end] = value[:begin] + 0.25 unless value[:end]
       value[:label] = "label_#{atome_hash[:markers].length}" unless value[:label]

data/lib/atome/renderers/browser/helpers/web_helper.rb

@@ -23,8 +23,4 @@ module BrowserHelper
     browser_object[:src] = value
   end
 
-  def self.browser_attach_web(parents, html_object, _atome)
-    html_object.append_to(browser_document[parents])
-  end
-
-end
+end

data/lib/atome/renderers/browser/identity.rb

@@ -3,6 +3,11 @@
 generator = Genesis.generator
 
 generator.build_render(:browser_id) do |params|
+  if @browser_type == :style
+    prev_content = @browser_object.inner_html
+    new_content = prev_content.sub(@browser_object.id, params)
+    @browser_object.inner_html = new_content
+  end
   browser_object.id = params if @atome[:id] != params
 end
 
@@ -10,17 +15,8 @@ generator.build_render(:browser_type) do |params|
   send("browser_#{params}", user_proc)
 end
 
-generator.build_render(:browser_parents) do |parents_found|
-  parents_found.each do |parent_found|
-    BrowserHelper.send("browser_attach_#{@browser_type}", parent_found, @browser_object, @atome)
-  end
-end
-
-generator.build_option(:pre_render_children) do |children_pass|
-  children_pass.each do |child_found|
-    atome_found = grab(child_found)
-    atome_found.parents([@atome[:id]])
-  end
+generator.build_render(:browser_family) do |parents_found|
+  BrowserHelper.send("browser_attach_#{@browser_type}", parents_found, @browser_object, @atome)
 end
 
 generator.build_render(:browser_attach) do |parents_found|

data/lib/atome/renderers/browser/material.rb

@@ -9,15 +9,21 @@ generator.build_render(:red) do |value|
   alpha = @atome[:alpha]
   color_updated = "rgba(#{red}, #{green}, #{blue}, #{alpha})"
   BrowserHelper.send("browser_colorize_#{@atome[:type]}", color_updated, @atome)
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
 end
 
 generator.build_render(:green) do |value|
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
   red = @atome[:red] * 255
   green = (@atome[:green] = value) * 255
   blue = @atome[:blue] * 255
   alpha = @atome[:alpha]
   color_updated = "rgba(#{red}, #{green}, #{blue}, #{alpha})"
   BrowserHelper.send("browser_colorize_#{@atome[:type]}", color_updated, @atome)
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
 end
 
 generator.build_render(:blue) do |value|
@@ -27,6 +33,8 @@ generator.build_render(:blue) do |value|
   alpha = @atome[:alpha]
   color_updated = "rgba(#{red}, #{green}, #{blue}, #{alpha})"
   BrowserHelper.send("browser_colorize_#{@atome[:type]}", color_updated, @atome)
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
 end
 
 generator.build_render(:alpha) do |value|
@@ -36,6 +44,8 @@ generator.build_render(:alpha) do |value|
   alpha = (@atome[:alpha] = value)
   color_updated = "rgba(#{red}, #{green}, #{blue}, #{alpha})"
   BrowserHelper.send("browser_colorize_#{@atome[:type]}", color_updated, @atome)
+  # we return self to allow syntax of the type : a.color(:black).red(1).green(0.3)
+  self
 end
 
 generator.build_render(:visual) do |value|

data/lib/atome/renderers/html/atome.rb

@@ -11,6 +11,8 @@ generator.build_render(:html_shape) do
   @html_object.attr('id', id_found)
 end
 
+generator.build_render(:html_element)
+
 generator.build_render(:html_color) do |_value|
   # we remove previous unused style tag
   opal_document[id]&.remove

data/lib/atome/renderers/renderer.rb

@@ -4,10 +4,11 @@
 class Atome
   private
 
-  def rendering(element_to_render, content, &user_proc)
+  def rendering(element, &user_proc)
+    params=instance_variable_get("@#{element}")
     render_engines = @atome[:renderers]
     render_engines.each do |render_engine|
-      send("#{render_engine}_#{element_to_render}", content, &user_proc)
+      send("#{render_engine}_#{element}", params, &user_proc)
     end
   end
 end

data/lib/atome/version.rb

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

data/lib/atome.rb

@@ -5,12 +5,12 @@ require 'atome/version'
 require 'atome/genesis/genesis'
 require 'atome/kernel/essentials'
 require 'atome/kernel/universe'
+require 'atome/kernel/batch'
 require 'atome/helpers/essentials'
 require 'atome/renderers/renderer'
 require 'atome/helpers/color_helper/color'
 require 'atome/extensions/atome'
 require 'atome/atome'
-require 'atome/helpers/utilities'
 require 'atome/helpers/callbacks'
 require 'atome/genesis/generators/atome'
 require 'atome/presets/atome'
@@ -23,6 +23,7 @@ require 'atome/genesis/generators/material'
 require 'atome/genesis/generators/spatial'
 require 'atome/genesis/generators/time'
 require 'atome/genesis/generators/utility'
+require 'atome/helpers/utilities'
 if RUBY_ENGINE.downcase == 'opal'
   require 'atome/renderers/browser/browser'
   require 'atome/renderers/html/html'

data/sig/atome.rbs

@@ -7,5 +7,19 @@ module Atome
 
   def add_to_hash: -> untyped
 
+  def apply_style: -> untyped
+
+  def format_matrix: -> untyped
+
+  def get_column: -> untyped
+
+  def get_column_or_row: -> untyped
+
+  def get_row: -> untyped
+
+  def matrix: -> untyped
+
+  def set: -> untyped
+
   def sort_callback: -> untyped
 end

data/vendor/assets/Rakefile

@@ -1,3 +1,3 @@
 task :build do
-  `atome build;open build/index.html`
+  `atome build;open src/index.html`
 end