flok 0.0.36 → 0.0.38

data/spec/env/etc.rb

@@ -1,2 +1,2 @@
+require './spec/env/global.rb'
 require './spec/lib/temp_dir'
-

data/spec/env/global.rb

@@ -0,0 +1,2 @@
+bin_path = File.join(File.dirname(__FILE__), "../../bin/")
+ENV['PATH'] = "#{bin_path}:#{ENV['PATH']}"

data/spec/env/iface.rb

@@ -1,3 +1,4 @@
+require './spec/env/global.rb'
 require 'json'
 require './spec/lib/rspec_extensions'
 require 'open3'
@@ -11,7 +12,7 @@ shared_context "iface:kern" do
   before(:each) do
     @pipe = IO.popen("rake pipe:kern", "r+")
     @pid = @pipe.pid
-    @mods = Flok::Platform.mods ENV['PLATFORM'], ENV['FLOK_ENV']
+    @mods = Flok::Platform.mods ENV['FLOK_ENV']
   end
 
   after(:each) do
@@ -27,7 +28,7 @@ shared_context "iface:driver" do
   before(:each) do 
     @pipe = IO.popen("rake pipe:driver", "r+") 
     @pid = @pipe.pid
-    @mods = Flok::Platform.mods ENV['PLATFORM'], ENV['FLOK_ENV']
+    @mods = Flok::Platform.mods ENV['FLOK_ENV']
   end
 
   after(:each) do
@@ -43,11 +44,11 @@ end
 
 #Get a list of modules based on the platform and environment
 def mods
-  Flok::Platform.mods ENV['PLATFORM'], ENV['FLOK_ENV']
+  Flok::Platform.mods ENV['FLOK_ENV']
 end
 
 def config_yml
-  Flok::Platform.config_yml ENV['PLATFORM'], ENV['FLOK_ENV']
+  Flok::Platform.config_yml ENV['FLOK_ENV']
 end
 
 #Ensure this platform supports a module, or skip the test (used inside before(:each) describe block, or `it` block)
@@ -62,3 +63,18 @@ def settings_dep key, value
   raise "#{ENV["PLATFORM"].inspect} does not support #{key.inspect} configuration in config.yml" unless config_yml.include? key
   skip "#{ENV["PLATFORM"].inspect} #{key.inspect} is not #{value.inspect} in config.yml; it is #{config_yml[key].inspect}"  unless value == config_yml[key]
 end
+
+#Restart the driver but persist any data that was saved
+def restart_driver_but_persist
+  #Ensure the pipe is fully drained before sending RESTART
+  @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
+
+  @pipe.puts "RESTART"
+  begin
+    Timeout::timeout(10) do
+      expect(@pipe.readline).to eq("RESTART OK\n")
+    end
+  rescue Timeout::Error
+    raise "Tried to restart driver but timed out waiting for 'RESTART OK'"
+  end
+end

data/spec/env/kern.rb

@@ -1,3 +1,4 @@
+require './spec/env/global.rb'
 require 'therubyracer'
 require './spec/lib/temp_dir'
 
@@ -20,21 +21,25 @@ shared_context "kern" do
     bin_path = File.join(File.dirname(__FILE__), "../../bin/flok")
 
     #Now execute the command with a set of arguments
-    system("#{bin_path} #{args}")
+    return system("#{bin_path} #{args}")
   end
 
   #Create a new flok project, add the given user_file (an .rb file containing controllers, etc.)
   #and then retrieve a V8 instance from this project's application_user.js
-  def flok_new_user user_controllers_src
+  def flok_new_user user_controllers_src, service_config=nil, service_src=nil
     temp_dir = new_temp_dir
     Dir.chdir temp_dir do
       flok "new test"
       Dir.chdir "test" do
         #Put controllers in
         File.write './app/controllers/user_controller.rb', user_controllers_src
+        File.write './config/services.rb', service_config if service_config
+        File.write './app/services/service0.rb', service_src if service_src
 
         #Build
-        flok "build" #Will generate drivers/ but we will ignore that
+        unless flok "build" #Will generate drivers/ but we will ignore that
+          raise "Build failed"
+        end
 
         #Execute
         @driver = FakeDriverContext.new

data/spec/etc/cli_spec.rb

@@ -35,69 +35,124 @@ def flok_new
 end
 
 RSpec.describe "CLI" do
- before(:all) do
+  before(:all) do
     #Uninstall old gems and install the current development gem
     system("rake gem:install")
   end
 
- it "Can be executed via bundle exec" do
-    flok_new do
-      flok "build"
-    end
-  end
-
-it "Can create a new project with correct directories" do
-    flok_new do
-      #Should include all entities in the project template with the exception
-      #of erb extenseded entities (which will still be included, but they each
-      #will not have the erb ending
-      template_nodes = nil
-      Dir.chdir File.join(File.dirname(__FILE__), "../../lib/flok/project_template") do
-        template_nodes = Dir["**/*"].map{|e| e.gsub(/\.erb$/i, "")}
-      end
-      new_proj_nodes = Dir["**/*"]
-      expect(new_proj_nodes.sort).to eq(template_nodes.sort)
-
-      expect(files).to include("Gemfile")
-    end
-  end
-
-  it "Can build a project with every type of platform" do
-    platform = ENV['PLATFORM']
-    flok_new do
-      #Build a new project
-      flok "build"
-
-      #Check it's products directory
-      expect(dirs).to include "products"
-      Dir.chdir "products" do
-        #Has a platform folder
-        expect(dirs).to include platform
-        Dir.chdir platform do
-          #Has an application_user.js file
-          expect(files).to include "application_user.js"
-
-          #The application_user.js contains both the glob/application.js and the glob/user_compiler.js
-          glob_application_js = File.read('glob/application.js')
-          glob_user_compiler_js = File.read('glob/user_compiler.js')
-          application_user_js = File.read('application_user.js')
-          expect(application_user_js).to include(glob_application_js)
-          expect(application_user_js).to include(glob_user_compiler_js)
-
-          #Contains the same files as the kernel in the drivers directory
-          expect(dirs).to include "drivers"
-        end
-      end
-    end
-  end
-
-  it "Can build a project with a controller file for each platform" do
+  #it "Can be executed via bundle exec" do flok_new do
+      #flok "build"
+    #end
+  #end
+
+  ##When this sets FLOK_CONFIG, the defines is added to the project config.yml
+  ##to show spec_helper_defines_spec_test. This text should show up in the final
+  ##source code
+  #it "Does set the FLOK_CONFIG to the correct file based on PLATFORM" do
+    #flok_new do
+      ##Set spec_test in project configuration
+      #config_yml = YAML.load_file("./config/platforms/#{ENV['PLATFORM']}/config.yml")
+      #config_yml["DEBUG"]["defines"] = ["spec_test"]
+      #File.write("./config/platforms/#{ENV['PLATFORM']}/config.yml", config_yml.to_yaml)
+
+      ##Now commit a build
+      #flok "build"
+
+      ##Now read the application_user file, it should contain the string located in `./app/kern/spec_helper.js`
+      ##that will only show if the correct defines is set
+      #application_user = File.read("./products/#{ENV['PLATFORM']}/application_user.js")
+      #expect(application_user).to include("spec_helper_defines_spec_test")
+    #end
+  #end
+
+  #it "Can create a new project with correct directories" do
+    #flok_new do
+      ##Should include all entities in the project template with the exception
+      ##of erb extenseded entities (which will still be included, but they each
+      ##will not have the erb ending
+      #template_nodes = nil
+      #Dir.chdir File.join(File.dirname(__FILE__), "../../lib/flok/project_template") do
+        #template_nodes = Dir["**/*"].map{|e| e.gsub(/\.erb$/i, "")}
+      #end
+      #new_proj_nodes = Dir["**/*"]
+      #expect(new_proj_nodes.sort).to eq(template_nodes.sort)
+
+      #expect(files).to include("Gemfile")
+    #end
+  #end
+
+  #it "Can build a project with every type of platform" do
+    #platform = ENV['PLATFORM']
+    #flok_new do
+      ##Build a new project
+      #flok "build"
+
+      ##Check it's products directory
+      #expect(dirs).to include "products"
+      #Dir.chdir "products" do
+        ##Has a platform folder
+        #expect(dirs).to include platform
+        #Dir.chdir platform do
+          ##Has an application_user.js file
+          #expect(files).to include "application_user.js"
+
+          ##The application_user.js contains both the glob/application.js and the glob/user_compiler.js
+          #glob_application_js = File.read('glob/application.js')
+          #glob_user_compiler_js = File.read('glob/user_compiler.js')
+          #application_user_js = File.read('application_user.js')
+          #expect(application_user_js).to include(glob_application_js)
+          #expect(application_user_js).to include(glob_user_compiler_js)
+
+          ##Contains the same files as the kernel in the drivers directory
+          #expect(dirs).to include "drivers"
+        #end
+      #end
+    #end
+  #end
+
+  #it "Can build a project with a controller file for each platform" do
+    ##Compile and then return the length of the application_user.js file
+    #def compile_with_file path=nil
+      ##Custom controller to test source with
+      #controller_src = File.read(path) if path
+      #flok_new do
+        #File.write "./app/controllers/controller0.rb", controller_src if path
+
+        ##Build a new project
+        #flok "build"
+
+        ##Check it's products directory
+        #Dir.chdir "products" do
+          ##Has a platform folder
+          #Dir.chdir @platform do
+            #glob_application_js = File.read('glob/application.js')
+            #glob_user_compiler_js = File.read('glob/user_compiler.js')
+            #application_user_js = File.read('application_user.js')
+
+            #return application_user_js.split("\n").count
+          #end
+        #end
+      #end
+    #end
+
+    #platform = ENV['PLATFORM']
+    #@platform = platform
+    #controller_rb = File.read('./spec/etc/user_compiler/controller0.rb')
+
+    ##The file with content should be longer when compiled into the flat application_user.js
+    #len_with_content = compile_with_file "./spec/etc/user_compiler/controller0.rb"
+    #len_no_content = compile_with_file
+
+    #expect(len_no_content).to be < len_with_content
+  #end
+
+  it "Can build a project with a javascript file for each platform" do
     #Compile and then return the length of the application_user.js file
     def compile_with_file path=nil
       #Custom controller to test source with
       controller_src = File.read(path) if path
       flok_new do
-        File.write "./app/controllers/controller0.rb", controller_src if path
+        File.write "./app/scripts/data.js", controller_src if path
 
         #Build a new project
         flok "build"
@@ -106,8 +161,6 @@ it "Can create a new project with correct directories" do
         Dir.chdir "products" do
           #Has a platform folder
           Dir.chdir @platform do
-            glob_application_js = File.read('glob/application.js')
-            glob_user_compiler_js = File.read('glob/user_compiler.js')
             application_user_js = File.read('application_user.js')
 
             return application_user_js.split("\n").count
@@ -118,119 +171,220 @@ it "Can create a new project with correct directories" do
 
     platform = ENV['PLATFORM']
     @platform = platform
-    controller_rb = File.read('./spec/etc/user_compiler/controller0.rb')
-
     #The file with content should be longer when compiled into the flat application_user.js
-    len_with_content = compile_with_file "./spec/etc/user_compiler/controller0.rb"
+    len_with_content = compile_with_file "./spec/etc/user_compiler/data.js"
     len_no_content = compile_with_file
 
     expect(len_no_content).to be < len_with_content
   end
 
-  include SpecHelpers
-  it "server does build project when first run" do
-    platform = ENV['PLATFORM']
-    flok_new do
-      #Now execute the command with a set of arguments
-      sh2("bundle exec flok server", /BUILD RAN/) do |inp, out|
-        #The server should always trigger a build on it's first run
-        expect(dirs).to include "products"
-        Dir.chdir "products" do
-          #Has a platform folder
-          expect(dirs).to include platform
-          Dir.chdir platform do
-            #Has an application_user.js file
-            expect(files).to include "application_user.js"
-
-            #The application_user.js contains both the glob/application.js and the glob/user_compiler.js
-            glob_application_js = File.read('glob/application.js')
-            glob_user_compiler_js = File.read('glob/user_compiler.js')
-            application_user_js = File.read('application_user.js')
-            expect(application_user_js).to include(glob_application_js)
-            expect(application_user_js).to include(glob_user_compiler_js)
-
-            #Contains the same files as the kernel in the drivers directory
-            expect(dirs).to include "drivers"
-          end
-        end
-      end
-    end
-  end
-
-  it "server does rebuild project when a file is added" do
-    platform = ENV['PLATFORM']
-    flok_new do
-      #Now execute the command with a set of arguments
-      sh2("bundle exec flok server", /BUILD RAN/) do |inp, out|
-        #Get the original build
-        application_user_js = File.read("products/#{platform}/application_user.js")
-
-        #Now add a file
-        File.write "./app/controllers/test2.rb", %{
-          controller "my_controller" do
-            action "my_action" do
-              on_entry %{
-              }
-            end
-          end
-        }
-
-        #Wait for a rebuild
-        expect(out).to readline_and_equal_x_within_y_seconds("BUILD RAN", 5.seconds)
-
-        #Get updated version
-        application_user_js2 = File.read("products/#{platform}/application_user.js")
-
-        #Make sure the compiled file is different and it's somewhat valid (length > 30)
-        expect(application_user_js2).not_to eq(application_user_js)
-        expect(application_user_js2.length).to be > 30 #Magic 30 to avoid any problems
-      end
-    end
-  end
-
-  it "server does host products on localhost:9992" do
-    platform = ENV['PLATFORM']
-    flok_new do
-      #Now execute the command with a set of arguments
-      sh2("bundle exec flok server", /BUILD RAN/) do |inp, out|
-        real_application_user_js = File.read("products/#{platform}/application_user.js")
-
-        #Grab the application_user.js file
-        res = wget "http://localhost:9992/application_user.js"
-        expect(res).not_to eq(nil)
-        expect(res.length).not_to eq(0)
-        expect(res).to eq(real_application_user_js)
-      end
-    end
-  end
-
-  it "server does host products on localhost:9992 and changes the products when the files change" do
-    platform = ENV['PLATFORM']
-    flok_new do
-      #Now execute the command with a set of arguments
-      sh2("bundle exec flok server", /BUILD RAN/) do |inp, out|
-        #Get the original
-        application_user_js = wget "http://localhost:9992/application_user.js"
-
-        #Now add a file
-        File.write "./app/controllers/test2.rb", %{
-          controller "my_controller" do
-            action "my_action" do
-              on_entry %{
-              }
-            end
-          end
-        }
-        #Wait for a rebuild
-        expect(out).to readline_and_equal_x_within_y_seconds("BUILD RAN", 5.seconds)
-
-        #Grab new version
-        application_user_js2 = wget "http://localhost:9992/application_user.js"
-
-        #Make sure the compiled file is different and it's longer
-        expect(application_user_js2.length).to be > application_user_js.length
-        expect(application_user_js2.length).to be > 30 #Make sure it's at least something
-      end
-    end
-  end
+  #it "Can build a project with an instantized service from the kernel ./app/kern/services folder" do
+    ##Compiled to config/services.rb
+    #def compile_with_file path=nil
+      #config_src = File.read(path) if path
+      #flok_new do
+        #File.write "./config/services.rb", config_src if path
+
+        ##Build a new project
+        #flok "build"
+
+        ##Check it's products directory
+        #Dir.chdir "products" do
+          ##Has a platform folder
+          #Dir.chdir @platform do
+            #application_user_js = File.read('application_user.js')
+
+            #return application_user_js.split("\n").count
+          #end
+        #end
+      #end
+    #end
+
+    #platform = ENV['PLATFORM']
+    #@platform = platform
+    #config_rb = File.read('./spec/etc/service_compiler/config0.rb')
+
+    ##The file with content should be longer when compiled into the flat application_user.js
+    #len_with_content = compile_with_file "./spec/etc/service_compiler/config0.rb"
+    #len_no_content = compile_with_file
+
+    #expect(len_no_content).to be < len_with_content
+  #end
+
+  #it "Can build a project with an instantized service from the user ./app/services folder" do
+    ##Compiled to config/services.rb
+    #def compile_with_file config_path=nil, src_path=nil
+      #config_src = File.read(config_path) if config_path
+      #src = File.read(src_path) if src_path
+      #flok_new do
+        #File.write "./config/services.rb", config_src if config_path
+        #File.write "./app/services/service0.rb", src if src_path 
+
+        ##Build a new project
+        #flok "build"
+
+        ##Check it's products directory
+        #Dir.chdir "products" do
+          ##Has a platform folder
+          #Dir.chdir @platform do
+            #application_user_js = File.read('application_user.js')
+
+            #return application_user_js.split("\n").count
+          #end
+        #end
+      #end
+    #end
+
+    #platform = ENV['PLATFORM']
+    #@platform = platform
+    #config_rb = File.read('./spec/etc/service_compiler/config1.rb')
+    #service_rb = File.read('./spec/etc/service_compiler/service0.rb')
+
+    ##The file with content should be longer when compiled into the flat application_user.js
+    #len_with_content = compile_with_file "./spec/etc/service_compiler/config1.rb", "./spec/etc/service_compiler/service0.rb"
+    #len_no_content = compile_with_file
+
+    #expect(len_no_content).to be < len_with_content
+  #end
+
+  #it "Can build a project with an instantized service from the user ./app/services folder and this has a function of the service" do
+    ##Compiled to config/services.rb
+    #def compile_with_file config_path=nil, src_path=nil
+      #config_src = File.read(config_path) if config_path
+      #src = File.read(src_path) if src_path
+      #flok_new do
+        #File.write "./config/services.rb", config_src if config_path
+        #File.write "./app/services/service0.rb", src if src_path 
+
+        ##Build a new project
+        #flok "build"
+
+        ##Check it's products directory
+        #Dir.chdir "products" do
+          ##Has a platform folder
+          #Dir.chdir @platform do
+            #application_user_js = File.read('application_user.js')
+
+            #return application_user_js
+          #end
+        #end
+      #end
+    #end
+
+    #platform = ENV['PLATFORM']
+    #@platform = platform
+    #config_rb = File.read('./spec/etc/service_compiler/config1.rb')
+    #service_rb = File.read('./spec/etc/service_compiler/service0.rb')
+
+    ##The file with content should be longer when compiled into the flat application_user.js
+    #res = compile_with_file "./spec/etc/service_compiler/config1.rb", "./spec/etc/service_compiler/service0.rb"
+    #expect(res).to include("function blah_on_wakeup()")
+  #end
+
+  #include SpecHelpers
+  #it "server does build project when first run" do
+    #platform = ENV['PLATFORM']
+    #flok_new do
+      ##Now execute the command with a set of arguments
+      #sh2("bundle exec flok server", /BUILD RAN/) do |inp, out|
+        ##The server should always trigger a build on it's first run
+        #expect(dirs).to include "products"
+        #Dir.chdir "products" do
+          ##Has a platform folder
+          #expect(dirs).to include platform
+          #Dir.chdir platform do
+            ##Has an application_user.js file
+            #expect(files).to include "application_user.js"
+
+            ##The application_user.js contains both the glob/application.js and the glob/user_compiler.js
+            #glob_application_js = File.read('glob/application.js')
+            #glob_user_compiler_js = File.read('glob/user_compiler.js')
+            #application_user_js = File.read('application_user.js')
+            #expect(application_user_js).to include(glob_application_js)
+            #expect(application_user_js).to include(glob_user_compiler_js)
+
+            ##Contains the same files as the kernel in the drivers directory
+            #expect(dirs).to include "drivers"
+          #end
+        #end
+      #end
+    #end
+  #end
+
+  #it "server does rebuild project when a file is added" do
+    #platform = ENV['PLATFORM']
+    #flok_new do
+      ##Now execute the command with a set of arguments
+      #sh2("bundle exec flok server", /BUILD RAN/) do |inp, out|
+        ##Get the original build
+        #application_user_js = File.read("products/#{platform}/application_user.js")
+
+        ##Now add a file
+        #File.write "./app/controllers/test2.rb", %{
+          #controller "my_controller" do
+            #action "my_action" do
+              #on_entry %{
+              #}
+            #end
+          #end
+        #}
+
+        ##Wait for a rebuild
+        #expect(out).to readline_and_equal_x_within_y_seconds("BUILD RAN", 5.seconds)
+
+        ##Get updated version
+        #application_user_js2 = File.read("products/#{platform}/application_user.js")
+
+        ##Make sure the compiled file is different and it's somewhat valid (length > 30)
+        #expect(application_user_js2).not_to eq(application_user_js)
+        #expect(application_user_js2.length).to be > 30 #Magic 30 to avoid any problems
+      #end
+    #end
+  #end
+
+  #it "server does host products on localhost:9992" do
+    #platform = ENV['PLATFORM']
+    #flok_new do
+      ##Now execute the command with a set of arguments
+      #sh2("bundle exec flok server", /BUILD RAN/) do |inp, out|
+        #real_application_user_js = File.read("products/#{platform}/application_user.js")
+
+        ##Grab the application_user.js file
+        #res = wget "http://localhost:9992/application_user.js"
+        #expect(res).not_to eq(nil)
+        #expect(res.length).not_to eq(0)
+        #expect(res).to eq(real_application_user_js)
+      #end
+    #end
+  #end
+
+  #it "server does host products on localhost:9992 and changes the products when the files change" do
+    #platform = ENV['PLATFORM']
+    #flok_new do
+      ##Now execute the command with a set of arguments
+      #sh2("bundle exec flok server", /BUILD RAN/) do |inp, out|
+        ##Get the original
+        #application_user_js = wget "http://localhost:9992/application_user.js"
+
+        ##Now add a file
+        #File.write "./app/controllers/test2.rb", %{
+          #controller "my_controller" do
+            #action "my_action" do
+              #on_entry %{
+              #}
+            #end
+          #end
+        #}
+        ##Wait for a rebuild
+        #expect(out).to readline_and_equal_x_within_y_seconds("BUILD RAN", 5.seconds)
+
+        ##Grab new version
+        #application_user_js2 = wget "http://localhost:9992/application_user.js"
+
+        ##Make sure the compiled file is different and it's longer
+        #expect(application_user_js2.length).to be > application_user_js.length
+        #expect(application_user_js2.length).to be > 30 #Make sure it's at least something
+      #end
+    #end
+  #end
 end