flok 0.0.20 → 0.0.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3406b13f8cf50a7c88224afaf47441a6ca0d128f
-  data.tar.gz: 8c4d7feb578ab38b1a9f4a60760cfec5fd00a268
+  metadata.gz: 1bdd0e73ce51527ed47bbeb40ec3f891488f4265
+  data.tar.gz: 692562bb5786d8cd4c03a74db6aa3954b8f64955
 SHA512:
-  metadata.gz: 50461e1bb7cbf544067d8746d0163620c25573dfc12dffc941c8f2f380610721f11b866427aa08a7f4c1c3e2fa80ac1e1a982b4e86dca1fdb02ef5fb4dc9b949
-  data.tar.gz: 8c43c4cd297e7b7bc5f37c5ee34b2c9e1ed9ae73562e459863aaf69dfe5fd4e7d0e51a73b734f104d2a46940ed8ce9feb1fb499b6cfe2e985f4bc27f8faed892
+  metadata.gz: 35d8ce34aa667a0d0d5c840e50ae4531167b67af3561057e0ab13a807a061e3af93ea6366dd308290958977e26cdf930ab8165c02fb755e150e2dfe1265c3bf4
+  data.tar.gz: 9698f5d86ba29a377308a4ab414744ad466959115dab251dc102f0a11337def7ef0e1c9d468ae6b1c7a96db190e1104dd34c01dde9052ef2d44ca6181453a8e7

data/bin/flok

@@ -3,6 +3,8 @@
 require 'flok'
 require 'thor'
 require 'fileutils'
+require 'webrick'
+require_relative '../spec/lib/helpers.rb'
 
 class FlokCLI < Thor
   desc "new <path>", "Create a new flok project and/or module, you may supply an absolute path or relative, the last entry in the path will be the module name and folder name of the project"
@@ -61,11 +63,49 @@ class FlokCLI < Thor
     end
   end
 
-  desc "server", "Monitors for changes within your flok application and triggers an automatic rebuild of ./products/* for a PLATFORM"
+  desc "server", "Monitors for changes within your flok application and triggers an automatic rebuild of ./products/* for a PLATFORM when something in ./app changes"
+  include SpecHelpers #Contains sh2
   def server platform
-    system('bundle exec guard')
+    File.write "Guardfile", %{
+      guard :shell, :all_on_start => true do
+        watch %r{^app/.*} do |m|
+          system("#{$0} build #{platform}")
+          res = system("#{$0} build #{platform}");
+          $stdout.puts "BUILD RAN"
+        end
+      end
+    }
+
+    #Ensure puts does something because it's on another thread
+    $stdout.sync = true
+
+    ###########################################################################
+    #We execute two tasks that run at the same time, (1) the webrick hoster
+    #and (2) the guard reloader that triggers build
+    ###########################################################################
+    #1) Launch webrick server
+    server = WEBrick::HTTPServer.new :Port => 9992, :DocumentRoot => "./products/#{platform}", :StartCallback => Proc.new {
+    }
+    server_started = false
+
+    #2) Wait for initial build to launch (all_on_start)
+    sh2("guard") do |inp, out|
+      loop do
+        res = out.readline
+        if res =~ /BUILD RAN/
+          #Start server
+          Thread.new { server.start } unless server_started
+          server_started = true
+
+          puts "BUILD RAN"
+        else
+          $stderr.puts res
+        end
+      end
+    end
   end
 
+  #Part of the build command
   class ERBUserApplicationContext
     def get_binding
       return binding

data/docs/project.md

@@ -6,6 +6,7 @@ You create and build projects via the `flok` command.
 
  * `flok new <path>` - Create a new flok project
  * `flok build <platform>` - Build a flok project. Generates files in `./products`
+ * `flok server <platform>` - Trigger auto-rebuild when a file is modified in the `./app` folder and hosts the `products/$PLATFORM` folder on `http://localhost:9992/`. e.g. `http://localhost:9992/application_user.js`
 
 ###Folder structure
   * `app/`

data/flok.gemspec

@@ -33,5 +33,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "thor", "~> 0.19"
   spec.add_runtime_dependency "rake", "~> 10.3"
   spec.add_runtime_dependency "therubyracer", "~> 0.12"
+  spec.add_runtime_dependency "guard", "~> 2.1"
+  spec.add_runtime_dependency "guard-shell", "~> 0.7"
   spec.executables << 'flok'
 end

data/lib/flok/version.rb

@@ -1,3 +1,3 @@
 module Flok
-  VERSION = "0.0.20"
+  VERSION = "0.0.21"
 end

data/spec/etc/cli_spec.rb

@@ -1,6 +1,8 @@
 Dir.chdir File.join File.dirname(__FILE__), '../../'
 require './spec/env/etc'
 require './lib/flok'
+require './spec/lib/helpers.rb'
+require './spec/lib/rspec_extensions.rb'
 
 require 'tempfile'
 require 'securerandom'
@@ -29,89 +31,252 @@ def flok_new
 end
 
 RSpec.describe "CLI" do
- 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["**/*"]
-      $stderr.puts "Flok version = #{Flok::VERSION}"
-      expect(new_proj_nodes).to eq(template_nodes)
+# 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["**/*"]
+      #$stderr.puts "Flok version = #{Flok::VERSION}"
+      #expect(new_proj_nodes).to eq(template_nodes)
 
-      expect(files).to include("Gemfile")
-    end
-  end
+      #expect(files).to include("Gemfile")
+    #end
+  #end
+
+  #it "Can build a project with every type of platform" do
+    #Flok.platforms.each do |platform|
+      #flok_new do
+        ##Build a new project
+        #flok "build #{platform}"
+
+        ##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
+  #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 #{@platform}"
+
+        ##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
+
+    #Flok.platforms.each do |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
+  #end
+
+  include SpecHelpers
+#  it "server does build project when first run" do
+    #Flok.platforms.each do |platform|
+      #flok_new do
+        ##Start the server
+        ##Get path to the flok binary relative to this file
+        #bin_path = File.join(File.dirname(__FILE__), "../../bin/flok")
+        #lib_path = File.join(File.dirname(__FILE__), "../../lib")
+
+        ##Now execute the command with a set of arguments
+        #sh2("ruby -I#{lib_path} #{bin_path} server #{platform}", /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)
 
-  it "Can build a project with every type of platform" do
+              ##Contains the same files as the kernel in the drivers directory
+              #expect(dirs).to include "drivers"
+            #end
+          #end
+        #end
+      #end
+    #end
+  #end
+
+  #it "server does rebuild project when a file is added" do
+    #Flok.platforms.each do |platform|
+      #flok_new do
+        ##Start the server
+        ##Get path to the flok binary relative to this file
+        #bin_path = File.join(File.dirname(__FILE__), "../../bin/flok")
+        #lib_path = File.join(File.dirname(__FILE__), "../../lib")
+
+        ##Now execute the command with a set of arguments
+        #sh2("ruby -I#{lib_path} #{bin_path} server #{platform}", /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
+              #view "my_controller"
+              #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
+  #end
+
+  it "server does delete existing products when a file is added (before it does a rebuild, i.e. clean)" do
     Flok.platforms.each do |platform|
       flok_new do
-        #Build a new project
-        flok "build #{platform}"
-
-        #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
+        #Start the server
+        #Get path to the flok binary relative to this file
+        bin_path = File.join(File.dirname(__FILE__), "../../bin/flok")
+        lib_path = File.join(File.dirname(__FILE__), "../../lib")
+
+        #Now execute the command with a set of arguments
+        sh2("ruby -I#{lib_path} #{bin_path} server #{platform}", /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
+              view "my_controller"
+              action "my_action" do
+                on_entry %{
+                }
+              end
+            end
+          }
+
+          #DONT Wait for a rebuild
+          is_dir = File.directory?("products/#{platform}")
+          expect(is_dir).to eq(false)
         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
+  #it "server does host products on localhost:9992" do
+    #Flok.platforms.each do |platform|
+      #flok_new do
+        ##Start the server
+        ##Get path to the flok binary relative to this file
+        #bin_path = File.join(File.dirname(__FILE__), "../../bin/flok")
+        #lib_path = File.join(File.dirname(__FILE__), "../../lib")
 
-        #Build a new project
-        flok "build #{@platform}"
+        ##Now execute the command with a set of arguments
+        #sh2("ruby -I#{lib_path} #{bin_path} server #{platform}", /BUILD RAN/) do |inp, out|
+          #real_application_user_js = File.read("products/#{platform}/application_user.js")
 
-        #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')
+          ##Grab the application_user.js file
+          #res = wget "http://localhost:9992/application_user.js"
+          #expect(res).to eq(real_application_user_js)
+        #end
+      #end
+    #end
+  #end
 
-            return application_user_js.split("\n").count
-          end
-        end
-      end
-    end
+  #it "server does host products on localhost:9992 and changes the products when the files change" do
+    #Flok.platforms.each do |platform|
+      #flok_new do
+        ##Start the server
+        ##Get path to the flok binary relative to this file
+        #bin_path = File.join(File.dirname(__FILE__), "../../bin/flok")
+        #lib_path = File.join(File.dirname(__FILE__), "../../lib")
 
-    Flok.platforms.each do |platform|
-      @platform = platform
-      controller_rb = File.read('./spec/etc/user_compiler/controller0.rb')
+        ##Now execute the command with a set of arguments
+        #sh2("ruby -I#{lib_path} #{bin_path} server #{platform}", /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
+              #view "my_controller"
+              #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)
 
-      #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
+          ##Grab new version
+          #application_user_js2 = wget "http://localhost:9992/application_user.js"
 
-      expect(len_no_content).to be < len_with_content
-    end
-  end
+          ##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
+  #end
 end

data/spec/lib/helpers.rb

@@ -1,6 +1,7 @@
 require 'securerandom'
 require 'json'
 require 'webrick'
+require 'open-uri'
 
 #Duplex pipe
 ###################################################################################################################
@@ -290,29 +291,39 @@ def sh2 *args
   end
 end
 
-#Execute some chrome code
-def chrome code, wait_for
-  #Load js assets
-  js_assets = Dir["./spec/assets/*.js"]
-  f = Tempfile.new(SecureRandom.hex)
-  js_assets.each do |fn|
-    f.puts File.read(fn)
-  end
+  #Execute some chrome code
+  def chrome code, wait_for
+    #Load js assets
+    js_assets = Dir["./spec/assets/*.js"]
+    f = Tempfile.new(SecureRandom.hex)
+    js_assets.each do |fn|
+      f.puts File.read(fn)
+    end
 
-  f.puts code
-  f.close
-  sh "boojs", f.path, wait_for do
-    yield
+    f.puts code
+    f.close
+    sh "boojs", f.path, wait_for do
+      yield
+    end
   end
-end
 
-#Get the result at an endpoint
-def get endpoint
-  uri = URI.parse(endpoint)
-  http = Net::HTTP.new(uri.host, uri.port)
-  request = Net::HTTP::Get.new(uri.request_uri)
-  response = http.request(request)
+  #Get the result at an endpoint
+  def get endpoint
+    uri = URI.parse(endpoint)
+    http = Net::HTTP.new(uri.host, uri.port)
+    request = Net::HTTP::Get.new(uri.request_uri)
+    response = http.request(request)
 
-  return JSON.parse(response.body)
-end
+    return JSON.parse(response.body)
+  end
+
+  def wget endpoint
+    begin
+      Timeout::timeout(5) do
+        return open(endpoint).read
+      end
+    rescue Timeout::Error
+      raise "Timed out while waiting for: #{endpoint.inspect}"
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flok
 version: !ruby/object:Gem::Version
-  version: 0.0.20
+  version: 0.0.21
 platform: ruby
 authors:
 - seo
@@ -220,6 +220,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: guard-shell
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
 description: Flok is a cross-platform application framework system that exports javascript
   files
 email: