plezi 0.12.22 → 0.14.0

data/resources/mini_exec

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# encoding: UTF-8
+
+# set the working directory
+cd "$(dirname "$0")"
+# load the website-app
+bundle exec iodine -t 16 -w 1 -www ./public

data/resources/procfile

@@ -0,0 +1,3 @@
+# Edit these parameters if you wish to leverage multi-process concurrency. i.e.:
+#    bundle exec iodine -p $PORT -t 16 -w 4 -www ./public -warmup # => 4 processes + fix lazy loading
+web: bundle exec iodine -p $PORT -t 16 -w 1 -www ./public

data/resources/rakefile

@@ -1,11 +1,7 @@
 # load all application code and gems
-load ::File.expand_path(File.join("..", "initialize.rb"),  __FILE__)
+require 'bundler'
+Bundler.require(:default, ENV['ENV'].to_s.to_sym)
 # set Plezi to rake mode and load it's tasks (if relevant).
-require "plezi/rake"
+Plezi.no_autostart
 
-# create a default task
-desc "The default task will simply remind you to call 'rake -T'."
-task :default do
-  puts "I don't know what to do. Please choose a task..."
-  puts "You can print a list of all avaiulable tasks using: rake -T"
-end
+# Add your tasks

data/resources/routes.rb

@@ -1,31 +1,14 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
+################
+# # Place your application routes here.
+# #
+# # Add your routes and controllers by order of priority.
 
-#########
-##
-## This file holds the routes for your application
-##
-## use the `host`, `route` and `shared_route` functions
-##
+# # I18n re-write, i.e.: `/en/home` will be rewriten as `/home`, while setting params['locale'] to "en"
+# Plezi.route "/:locale" , /^(#{I18n.available_locales.join "|"})$/ if defined? I18n
 
-
-# This is an optional re-write route for I18n.
-# i.e.: `/en/home` will be rewriten as `/home`, while setting params[:locale] to "en"
-route "/:locale{#{I18n.available_locales.join "|"}}/*" , false if defined? I18n
-
-# # This is an optional re-write route response formats.
 # # Response format re-write, i.e.: `/xml/home` will use .xml templates automatically
 # # with :locale a request might look like `/en/json/...`
-# route "/:format{html|json|xml}/*" , false
-
-###
-# add your routes here:
-
-
-# remove this demo route and the SampleController once you want to feed Plezi your code.
-route '/', SampleController
-
+# Plezi.route "/:format" , /^(html|json|xml)$/
 
-# this is a catch all route with a stub controller.
-# un comment the following line and replace the controller if you want a catch-all route.
-# route '*',  Plezi::StubRESTCtrl
+# The root Controller
+Plezi.route '/', RootController

data/resources/{websockets.js → simple-client.js}

@@ -7,8 +7,8 @@
 
 // Your websocket URI should be an absolute path. The following sets the base URI.
 // remember to update to the specific controller's path to your websocket URI.
-var ws_controller_path = window.location.pathname; // change to '/controller/path'
-var ws_uri = (window.location.protocol.match(/https/) ? 'wss' : 'ws') + '://' + window.document.location.host + ws_controller_path
+var ws_controller_path = windselfow.location.pathname; // change to '/controller/path'
+var ws_uri = (self.location.protocol.match(/https/) ? 'wss' : 'ws') + '://' + self.document.location.host + ws_controller_path
 // websocket variable.
 var websocket = NaN
 // count failed attempts
@@ -55,4 +55,4 @@ function init_websocket()
 	};
 }
 // setup the websocket connection once the page is done loading
-window.addEventListener("load", init_websocket, false); 
+self.addEventListener("load", init_websocket, false); 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plezi
 version: !ruby/object:Gem::Version
-  version: 0.12.22
+  version: 0.14.0
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2016-02-06 00:00:00.000000000 Z
+date: 2016-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: iodine
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.20
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.20
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.12'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -52,10 +52,23 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
-description: Plezi - the easy way to add Websockets, RESTful routing and HTTP streaming
-  services to Ruby Web-Apps.
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: The Plezi.io Ruby Framework for real time web applications.
 email:
-- boaz@2be.co.il
+- bo@plezi.io
 executables:
 - plezi
 extensions: []
@@ -68,86 +81,54 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- bin/plezi
-- docs/async_helpers.md
-- docs/controllers.md
-- docs/logging.md
-- docs/routes.md
-- docs/websockets.md
+- bin/config.ru
+- bin/console
+- bin/hello_world
+- bin/setup
+- exe/plezi
 - lib/plezi.rb
-- lib/plezi/builders/ac_model.rb
-- lib/plezi/builders/app_builder.rb
-- lib/plezi/builders/builder.rb
-- lib/plezi/builders/form_builder.rb
-- lib/plezi/common/api.rb
-- lib/plezi/common/cache.rb
-- lib/plezi/common/defer.rb
-- lib/plezi/common/dsl.rb
-- lib/plezi/common/redis.rb
-- lib/plezi/common/renderer.rb
-- lib/plezi/common/settings.rb
-- lib/plezi/handlers/controller_core.rb
-- lib/plezi/handlers/controller_magic.rb
-- lib/plezi/handlers/http_router.rb
-- lib/plezi/handlers/placebo.rb
-- lib/plezi/handlers/route.rb
-- lib/plezi/handlers/session.rb
-- lib/plezi/handlers/stubs.rb
-- lib/plezi/handlers/ws_identity.rb
-- lib/plezi/handlers/ws_object.rb
-- lib/plezi/helpers/http_sender.rb
-- lib/plezi/helpers/magic_helpers.rb
-- lib/plezi/helpers/mime_types.rb
-- lib/plezi/oauth.rb
-- lib/plezi/oauth/auth_controller.rb
+- lib/plezi/activation.rb
+- lib/plezi/api.rb
+- lib/plezi/controller/controller.rb
+- lib/plezi/controller/controller_class.rb
+- lib/plezi/controller/cookies.rb
+- lib/plezi/helpers.rb
 - lib/plezi/rake.rb
+- lib/plezi/render/erb.rb
+- lib/plezi/render/has_cache.rb
+- lib/plezi/render/markdown.rb
+- lib/plezi/render/render.rb
+- lib/plezi/render/sass.rb
+- lib/plezi/render/slim.rb
+- lib/plezi/router/adclient.rb
+- lib/plezi/router/assets.rb
+- lib/plezi/router/errors.rb
+- lib/plezi/router/route.rb
+- lib/plezi/router/router.rb
 - lib/plezi/version.rb
-- logo/dark.png
-- logo/light.png
-- logo/sign.png
+- lib/plezi/websockets/message_dispatch.rb
+- lib/plezi/websockets/redis.rb
 - plezi.gemspec
 - resources/404.erb
-- resources/404.haml
-- resources/404.html
-- resources/404.slim
 - resources/500.erb
-- resources/500.haml
-- resources/500.html
-- resources/500.slim
-- resources/Gemfile
-- resources/code.rb
+- resources/503.html
+- resources/client.js
 - resources/config.ru
-- resources/controller.rb
-- resources/database.yml
-- resources/db_ac_config.rb
-- resources/db_dm_config.rb
-- resources/db_sequel_config.rb
-- resources/en.yml
-- resources/haml_config.rb
-- resources/i18n_config.rb
-- resources/initialize.rb
+- resources/ctrlr.rb
+- resources/gemfile
 - resources/mini_app.rb
-- resources/mini_exec.rb
+- resources/mini_exec
 - resources/mini_welcome_page.html
-- resources/oauth_config.rb
-- resources/plezi_client.js
-- resources/plezi_websockets.html
+- resources/procfile
 - resources/rakefile
-- resources/redis_config.rb
 - resources/routes.rb
-- resources/slim_config.rb
-- resources/websockets.js
-- resources/welcome_page.html
-- test/console
-- test/dispatch
-- test/hello_world
-- test/plezi_tests.rb
-homepage: http://www.plezi.io/
+- resources/simple-client.js
+homepage: http://plezi.io
 licenses:
 - MIT
-metadata: {}
-post_install_message: Thank you for installing Plezi, the native Ruby Framework for
-  real time web-apps.
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -166,11 +147,5 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Plezi - the easy way to add Websockets, RESTful routing and HTTP streaming
-  services to Ruby Web-Apps.
-test_files:
-- test/console
-- test/dispatch
-- test/hello_world
-- test/plezi_tests.rb
-has_rdoc: 
+summary: The Plezi.io Ruby Framework for real time web applications.
+test_files: []

data/bin/plezi

@@ -1,104 +0,0 @@
-#!/usr/bin/env ruby
-$0="Plezi Builder"
-# count lines of code with: ^[ \t]*[\w\d\"\(\{\@\[\]\}\)\:\'\.\*\&]+.*$
-
-require 'irb'
-require 'benchmark'
-require 'securerandom'
-require 'plezi/builders/builder'
-require 'plezi/builders/app_builder'
-
-
-
-######################################################################
-# tweek the string class for termial coloring options
-class String
-  # colorization
-  def colorize(color_code)
-    "\e[#{color_code}m#{self}\e[0m"
-  end
-
-  def red
-    colorize(31)
-  end
-
-  def green
-    colorize(32)
-  end
-
-  def yellow
-    colorize(33)
-  end
-
-  def pink
-    colorize(35)
-  end
-end
-
-######################################################################
-######################################################################
-##
-## Start the Build script
-##
-######################################################################
-######################################################################
-
-# update with http://ruby-doc.org/stdlib-2.2.0/libdoc/optparse/rdoc/OptionParser.html
-
-# require 'optparser'
-
-if ARGV[0] == 'new' || ARGV[0] == 'n' || ARGV[0] == "force" || ARGV[0] == 'mini' || ARGV[0] == 'm' 
-	#########
-	## set up building environment
-	ARGV[1] = ARGV[1].gsub /[^a-zA-Z0-9]/, '_'
-	if Dir.exists?(ARGV[1]) && ARGV[0] != "force"
-		puts ""
-		puts "WARNING: app/folder alread exists, use `plezi fource #{ARGV[1]}` to attempt rebuild (no files will be overwritten).".red
-		puts ""
-		exit
-	end
-	if Dir.exists?(ARGV[1]) && ARGV[0] == "force"
-		Dir.chdir ARGV[1]
-		require ::File.expand_path(::Dir["."][0], ( ARGV[1] + ".rb") )
-		Dir.chdir '..'
-	end
-
-	# building
-	template = Plezi::Base::AppBuilder.new
-	(ARGV[0] == 'mini' || ARGV[0] == 'm' ) ? template.build_mini(ARGV[1]) : template.build(ARGV[1])
-elsif ARGV[0] == 'server' || ARGV[0] == 'start' || ARGV[0] == 's'
-	ARGV.shift
-	load File.expand_path(Dir["."][0], (File.expand_path(Dir["."][0]).split(/[\\\/]/).last) ) rescue load( File.expand_path(Dir["."][0], (File.expand_path(Dir["."][0]).split(/[\\\/]/).last ) ) )
-elsif ARGV[0] == 'console' || ARGV[0] == 'c'
-	load File.expand_path(Dir["."][0], (File.expand_path(Dir["."][0]).split(/[\\\/]/).last) ) rescue load( File.expand_path(Dir["."][0], (File.expand_path(Dir["."][0]).split(/[\\\/]/).last) ) )
-	ARGV.clear
-	Iodine.protocol = nil
-	IRB.start
-else
-	puts ""
-	puts "Plezi fast web app starter.".pink
-	puts "use: plezi new appname"
-	puts "or: plezi new appname with template-gem-to-put-in another-template-gem-to-put"
-	puts "==============================".green
-	puts "new app options:".pink
-	puts "option                  description".yellow
-	puts "new <appname>           creates a new application called <appname>."
-	puts "n                       alias for new."
-	puts "mini <appname>          creates a new mini-application called <appname>."
-	puts "m                       alias for mini."
-	puts "starting up an app:".pink
-	puts "start                   attempts to run the app. accepts any parameters the app supports."
-	puts "s                       alias for start/server."
-	puts "start console innsead of services:".pink
-	puts "console                 runs the app. accepts any parameters the app supports."
-	puts "c                       alias for start/server."
-	puts "==============================".green
-	puts ""
-	puts "Run the app using the app's script with an optional: -p {port number}. i.e."
-	puts "    cd ./appname".pink
-	puts "    ./appname -p 8080".pink
-	puts ""
-end
-
-
-

data/docs/async_helpers.md

@@ -1,245 +0,0 @@
-# Plezi's Asynchronous Engine
-
-(todo: write documentation)
-
-Inside Plezi's core code is a pure Ruby IO reactor called [Iodine](https://github.com/boazsegev/iodine), a wonderful Asynchronous Workflow Engine that allows us to enjoy both Multi-Threading and Multi-Processing.
-
-Although multi-threading is highly regarded, it should be pointed out that using the [Iodine](https://github.com/boazsegev/iodine) with just one thread is both faster and more efficient. But, since some tasks that take more time (blocking tasks) can't be broken down into smaller tasks, using a number of threads (and/or processes) is a better practice.
-
-You can read more about [Iodine](https://github.com/boazsegev/iodine) and it's amazing features in it's [documentation](http://www.rubydoc.info/github/boazsegev/iodine/master).
-
-Here we will discuss the methods used for asynchronous processing of different tasks that allow us to break big heavy tasks into smaller bits, allowing our application to 'flow' and stay responsive even while under heavy loads.
-
-## Asynchronous HTTP responses
-
-Inside Plezi's core code is a pure Ruby Http and Websocket Server (and client) that comes with [Iodine](https://github.com/boazsegev/iodine) and allows for native Http/1.1 streaming using `chunked` encoding or native Http/2 streaming (built-in to the protocol).
-
-Asynchronous Http method calls can be nested, but shouldn't be called one after the other.
-
-i.e.:
-
-```ruby
-# right
-response.stream_async {  response.stream_async {'do after'}; 'do first'  }
-# wrong
-response.stream_async {  "who's first?"  }
-response.stream_async {  "I don't know..."  }
-```
-
-Since streaming is done asynchronously, and since Plezi is multi-threaded by default (this can be changed to single threaded, but is less recomended unless you know your code doesn't block - see `Plezi::Settings.max_threads = number`), Asynchronous HTTP method nesting makes sure that the code doesn't conflict and that race conditions don't occure within the same HTTP response.
-
-
-#### Iodines's `response.stream_async &block`
-
-Iodines's response object, which is accessed by the controller using the `response` method (or the `@response` object), allows easy access to HTTP streaming.
-
-For example (run this in the terminal using `irb`):
-
-```ruby
-require `plezi`
-
-class MyController
-    def index
-        response.stream_async do
-            response << "This will stream.\n"
-            response.stream_async do
-                response << "Streaming can be nested."
-            end
-        end
-    end
-end
-
-route '/', MyController
-
-exit
-```
-
-As noted above, `response.stream_async` calls should always be nested and never called in 'parallel'.
-
-Calling `response.stream_async`
-
-#### Iodines's `response.stream_array enum, &block`
-
-To make nesting easier, Iodines's response object provides the `response.stream_array enum, &block` method.
-
-Here's our modified example:
-
-```ruby
-require 'plezi'
-
-class MyController
-    def index
-        data = ["This will stream.\n", "Streaming can be nested."]
-        response.stream_array(data) {|s| response << s}
-    end
-end
-
-route '/', MyController
-
-exit
-```
-
-You can also add data to the array while 'looping', which allows you to use the array as a 'flag' for looped streaming. The following is a very limited example, which could be used for "lazy loading" data from a database, in order to save on system resources or send large table data using JSON "packets".
-
-```ruby
-require 'plezi'
-
-class MyController
-    def index
-        data = ["This will stream.\n", "Streaming can be nested."]
-        flag = [true]
-        response.stream_array(flag) do
-            response << data.shift
-            flag << true unless data.empty?
-        end
-    end
-end
-
-route '/', MyController
-
-exit
-```
-
-## Asynchronous code execution
-
-[Iodine](https://github.com/boazsegev/iodine) has a very powerful Asynchronous Workflow Engine which offers a very intuitve and simplified way to use API both for queuing code snippets (blocks / methods) and for schedualing non-persistent timed events (future timed events are discarded during shutdown and need to be re-initiated).
-
-### The Asynchronous "Queue"
-
-`Iodine`'s core is built with simplicity in mind, making the programmer happy. With this in mind, Iodine offers a single and simple method that allow us to easily queue code execution.
-
-
-#### `Iodine.run(arg1, arg2, arg3...) {block}`
-
-`Iodine.run` takes arguments to be passed to a block of code prior to execution. This allows us to seperate the `Proc` object creation fron the data handling and possibly (but not always) optimize our code.
-
-For example:
-
-```ruby
-require 'plezi'
-
-class MyController
-    def index
-        # Plezi.run automatically defers to Iodine.run
-        Plezi.run(Time.now) {|t| puts "Someone poked me at: #{t}" } # maybe send an email?
-        "Hello World"
-    end
-end
-
-
-route '/', MyController
-
-exit
-```
-
-This might be optimized like so:
-
-```ruby
-require 'plezi'
-
-class MyController
-    def index
-        Iodine.run Time.now, &self.class.action_proc
-        "Hello World"
-    end
-
-    protected
-
-    def self.action_proc
-        @proc ||= Proc.new {|t| puts "Someone poked me at: #{t}" } # maybe send an email?
-    end
-end
-
-route '/', MyController
-
-exit
-```
-
-### Timed events
-
-Sometimes we want to schedule something to be done in a while, ormaybe we want a task to repeat every certain intevral...
-
-In come Iodine's TimedEvents: `Iodine.run_after` and `Iodine.run_every`
-
-#### `Iodine.run_every(seconds, arg1, arg2...) {|arg1, arg2..., timed_event| block }`
-
-`Iodine.run_every` is very similar to the `Iodine.run`, except it automatically injects an argument to our block, the timed even itself, as the last (optional) parameter. This allows us to stop the repeating event should the need arise.
-
-```ruby
-require 'plezi'
-
-class MyController
-    def index
-        counter = 0
-        # Plezi.run_every automatically defers to Iodine.run_every
-        Plezi.run_every(1, "Counting: %i") do |str, timer|
-            counter +=1
-            puts(str % counter)
-            timer.stop! if counter >= 3
-        end
-        "Hello World"
-    end
-end
-
-
-route '/', MyController
-
-exit
-```
-
-A similar approach could have been accomplished by setting a repeat limit:
-
-```ruby
-require 'plezi'
-
-class MyController
-    def index
-        timer = Iodine.run_every(1, "Counting down: %i") do |str, timer|
-            puts(str % timer.repeat_limit)
-        end
-        timer.repeat_limit = 3
-        "Hello World"
-    end
-end
-
-
-route '/', MyController
-
-exit
-```
-
-#### `Iodine.run_after(seconds, arg1, arg2...) {|arg1, arg2..., timed_event| block}`
-
-`Iodine.run_after` is very similar to the `Iodine.run_every`, except it is designed to "self destruct" after only only execution.
-
-The timed event allows us to create a new event with the same job, if we wish to.
-
-```ruby
-require 'plezi'
-
-class MyController
-    def index
-        counter = 0
-        # Plezi.run_after automatically defers to Iodine.run_after
-        Iodine.run_after(1, "Counting: %i") do |str, timer|
-            counter +=1
-            puts(str % counter)
-            Iodine.run_after(1, str, &timer.job) if counter < 3
-        end
-        "Hello World"
-    end
-end
-
-
-route '/', MyController
-
-exit
-```
-
-/// To Do: complete doc.
-
-## The Graceful Shutdown
-
-Enter `Iodine.on_shutdown` - a reverse shutdown task queue (LIFO).
-
-/// To Do: complete doc.