plezi 0.12.22 → 0.14.0

data/Rakefile

@@ -1,7 +1,10 @@
 require "bundler/gem_tasks"
+require "rake/testtask"
 
-# create a default task
-desc "Tests most of the basic features for the Plezi framework."
-task :test do
-	load "./test/plezi_tests.rb"
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
 end
+
+task :default => :test

data/bin/config.ru

@@ -0,0 +1,22 @@
+require 'benchmark'
+
+require 'plezi'
+# our Plezi application
+class MyCtrl
+  def index
+    'Hello from Plezi!'
+  end
+end
+# rewites
+Plezi.route '(:format)', /^(json|html)$/
+# Our Plezi route
+Plezi.route 'plezi/*', MyCtrl
+# The Rack application
+app = proc { |env| req = Rack::Request.new(env); str = "Params: #{req.params}"; [200, { 'Content-Length' => str.bytesize.to_s }, [str]] }
+# Use Plezi as Middleware
+use Plezi
+# run our Rack application
+run app
+
+# ab -n 1000000 -c 2000 -k http://127.0.0.1:3000/
+# wrk -c400 -d5 -t12 http://localhost:3000/

data/{test → bin}/console

@@ -1,10 +1,8 @@
 #!/usr/bin/env ruby
-# encoding: UTF-8
 
-require 'benchmark'
-$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), __FILE__ )
-require "plezi"
-require "bundler/setup"
+Dir.chdir(File.expand_path(File.join('..', '..', 'lib'), __FILE__))
+require 'bundler/setup'
+require 'plezi'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -13,5 +11,5 @@ require "bundler/setup"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start

data/bin/hello_world

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+require 'benchmark'
+Dir.chdir(File.expand_path(File.join('..', '..', 'lib'), __FILE__))
+require 'bundler/setup'
+require 'plezi'
+class WebsocketSample
+  # every request that routes to this controller will create a new instance
+  def initialize
+  end
+
+  # Http methods are available
+  def index
+    'Hello World!'
+  end
+
+  # RESTful methods are available
+  def show
+    "showing object with id: #{params['id']}..."
+  end
+
+  # called before the protocol is swithed from HTTP to WebSockets.
+  #
+  # this allows setting headers, cookies and other data (such as authentication)
+  # prior to opening a WebSocket.
+  #
+  # if the method returns false, the connection will be refused and the remaining routes will be attempted.
+  def pre_connect
+    true
+  end
+
+  # called immediately after a WebSocket connection has been established.
+  # it blocks all the connection's actions until the `on_open` initialization is finished.
+  def on_open
+  end
+
+  # called when new data is recieved
+  #
+  # data is a string that contains binary or UTF8 (message dependent) data.
+  def on_message(data)
+    Plezi.info "Websocket got: #{data}"
+  end
+
+  # called once, AFTER the connection was closed.
+  def on_close
+  end
+
+  # called once, during **server shutdown**, BEFORE the connection is closed.
+  # this will only be called for connections that are open while the server is shutting down.
+  def on_shutdown
+  end
+end
+Plezi.route '/', WebsocketSample

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/plezi

@@ -0,0 +1,145 @@
+#!/usr/bin/env ruby
+$0 = 'Plezi Builder'
+# count lines of code with: ^[ \t]*[\w\d\"\(\{\@\[\]\}\)\:\'\.\*\&]+.*$
+require 'pathname'
+require 'securerandom'
+######################################################################
+# 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
+
+module Builder
+  Root ||= Pathname.new(File.dirname(__FILE__)).expand_path.join('..')
+
+  def self.app_tree
+    @app_tree ||= {}.dup
+  end
+
+  def self.write_files(files, parent = '.')
+    if files.is_a? Hash
+      files.each do |k, v|
+        if v.is_a? Hash
+          begin
+            Dir.mkdir k
+            puts "    created #{parent}/#{k}".green
+          rescue => e
+            puts "    exists #{parent}/#{k}".red
+          end
+          Dir.chdir k
+          write_files v, (parent + '/' + k)
+          Dir.chdir '..'
+        elsif v.is_a? String
+          if ::File.exist? k
+            puts "    EXISTS(!) #{parent}/#{k}".red
+          else
+            IO.write k, v
+            puts "    wrote #{parent}/#{k}".yellow
+          end
+        end
+      end
+    end
+  end
+
+  def self.create_app(app_name = ARGV[1])
+    require Root.join('lib', 'plezi', 'version')
+    app_tree[app_name.to_s] ||= IO.read(Root.join('resources', 'mini_exec')).gsub('appname', app_name)
+    app_tree["#{app_name}.rb"] ||= IO.read(Root.join('resources', 'mini_app.rb')).gsub('appname', app_name).gsub('appsecret', "#{app_name}_#{SecureRandom.hex}")
+    app_tree['routes.rb'] ||= IO.read(Root.join('resources', 'routes.rb')).gsub('appname', app_name)
+    app_tree['config.ru'] ||= IO.read(Root.join('resources', 'config.ru')).gsub('appname', app_name)
+    app_tree['Procfile'] ||=  IO.read(Root.join('resources', 'procfile')).gsub('appname', app_name)
+    app_tree['Gemfile'] ||= ''
+    app_tree['Gemfile'] << "source 'https://rubygems.org'\n\n# include the basic plezi framework and server\ngem 'plezi', '~> #{Plezi::VERSION}'\n"
+    app_tree['Gemfile'] << IO.read(Root.join('resources', 'gemfile'))
+    app_tree['Gemfile'] << "\n\nruby '#{RUBY_VERSION}'\n"
+    app_tree['rakefile'] ||= IO.read(Root.join('resources', 'rakefile'))
+    app_tree['app'] ||= {}
+    app_tree['app']['my_controler.rb'] ||= IO.read(Root.join('resources', 'ctrlr.rb')).gsub('appname', app_name)
+    app_tree['views'] ||= {}
+    app_tree['views']['welcome.html.erb'] ||= IO.read(Root.join('resources', 'mini_welcome_page.html')).gsub('appname', app_name)
+    app_tree['views']['404.html.erb'] ||= IO.read(Root.join('resources', '404.erb'))
+    app_tree['views']['500.html.erb'] ||= IO.read(Root.join('resources', '500.erb'))
+    app_tree['views']['503.html'] ||= IO.read(Root.join('resources', '503.html'))
+    app_tree['public'] ||= {}
+    app_tree['public']['javascripts'] ||= {}
+    app_tree['public']['javascripts']['client.js'] ||= IO.read(Root.join('resources', 'client.js')).gsub('appname', app_name)
+    app_tree['public']['javascripts']['simple-client.js'] ||= IO.read(Root.join('resources', 'simple-client.js')).gsub('appname', app_name)
+
+    begin
+      Dir.mkdir app_name
+      puts "created the #{app_name} application directory.".green
+    rescue => e
+      puts "the #{app_name} application directory exists - trying to rebuild (no overwrite).".pink
+    end
+    Dir.chdir app_name
+    puts 'starting to write template data...'.red
+    puts ''
+    Builder.write_files app_tree
+    begin
+      File.chmod 0o775, app_name.to_s
+    rescue
+      true
+    end
+    puts 'done.'
+    puts ''
+    puts "please change directory into the app directory: cd #{app_name}"
+    puts ''
+    puts "run the #{app_name} app using: ./#{app_name} or using the iodine / rackup commands."
+    puts ''
+  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'
+  #########
+  ## set up building environment
+  ARGV[1] = ARGV[1].gsub(/[^a-zA-Z0-9]/, '_')
+  ARGV[1].downcase!
+  if Dir.exist?(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
+  Builder.create_app
+else
+  puts ''
+  puts 'Plezi fast web app starter.'.pink
+  puts 'use: plezi new appname'
+  puts 'or: plezi n appname'
+  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/lib/plezi.rb

@@ -1,147 +1,34 @@
-### Ruby core extentions
+require 'plezi/version'
+require 'iodine'
 
-require 'singleton'
-require 'pathname'
-require 'base64'
-require 'digest/sha1'
-require 'securerandom'
-require 'time'
-require 'json'
-require 'yaml'
-require 'uri'
-require 'set'
-
-# Iodine server
-require 'iodine/http'
-
-### version
-
-require "plezi/version"
-
-### common
-
-require 'plezi/common/defer.rb'
-require 'plezi/common/cache.rb'
-require 'plezi/common/api.rb'
-require 'plezi/common/dsl.rb'
-require 'plezi/common/redis.rb'
-require 'plezi/common/settings.rb'
-require 'plezi/common/renderer.rb'
-
-### helpers
-require 'plezi/helpers/magic_helpers.rb'
-require 'plezi/helpers/mime_types.rb'
-
-### HTTP and WebSocket Handlers
-require 'plezi/handlers/http_router.rb'
-require 'plezi/handlers/route.rb'
-require 'plezi/handlers/ws_object.rb'
-require 'plezi/handlers/ws_identity.rb'
-require 'plezi/handlers/controller_magic.rb'
-require 'plezi/handlers/controller_core.rb'
-require 'plezi/handlers/placebo.rb'
-require 'plezi/handlers/stubs.rb'
-require 'plezi/handlers/session.rb'
-
-# error and last resort handling
-require 'plezi/helpers/http_sender.rb'
-
-## erb templating
-begin
-	require 'erb'
-rescue 
+require 'plezi/api'
+require 'plezi/controller/controller'
 
+# Plezi is amazing. Read the {README}
+module Plezi
+  # Shhh... the modules and classes defined under the {Base} namespace are sleeping...
+  #
+  # The namespace signifies that Plezi uses these modules and classes internally.
+  # We don't need to worry about these unless we're monkey-patching stuff or contributing to the Plezi project.
+  module Base
+  end
 end
 
-##############################################################################
-#
-# Plezi is an easy to use Ruby Websocket Framework, with full RESTful routing support and HTTP streaming support. It's name comes from the word "fun" in Haitian, since Plezi is really fun to work with and it keeps our code clean and streamlined.
-#
-# Plezi is a wonderful alternative to Socket.io which makes writing the server using Ruby a breeze. 
-#
-# Plezi is multi-threaded by default (you can change this) and supports asynchronous callbacks,
-# so it will keep going even if some requests take a while to compute.
-#
-# Plezi routes accept controller classes, which makes RESTful and WebSocket applications easy to write.
-# For example, open your Ruby terminal (the `irb` command) and type:
-#
-#    require 'plezi'
-#    route "*", Plezi::StubRESTCtrl
-#    exit # will start the service.
-#
-# Controller classes don't need to inherit anything :-)
-#
-# Plezi's routing systems inherits the Controller class, allowing you more freedom in your code.
-#
-#    require 'plezi'
-#    class MyController
-#       def index
-#          "Hello World!"
-#       end
-#    end
-#    route "*", MyController
+###############
+## Dev notes.
+###############
 #
-#    exit # I'll stop writing this line every time.
+# Plezi 0.13.0 is heaviliy Rack based. Whenever Possible, Rack middleware was preffered.
+# The is a list of available Rack middleware:
+# * https://github.com/rack/rack/wiki/List-of-Middleware
 #
-# Amazing(!), right? - You can read more in the documentation for Plezi::StubWSCtrl and Plezi::StubRESTCtrl, which are stub classes used for testing routes.
 #
-# Plezi routes accept Regexp's (regular exceptions) for route paths.
-# Plezi also accepts an optional block instead of the conrtoller Class object for example:
 #
-#    require 'plezi'
-#    route(/[.]*/) {|request, response| response << "Your request, master: #{request.path}."}
 #
-# As you may have noticed before, the catch-all route (/[.]*/) has a shortcut: '*'.
 #
-# class routes that have a specific path (including root, but not a catch-all or Regexp path)
-# accept an implied `params[:id]` variable. the following path ('/'):
-#
-#    require 'plezi'
-#    route "/", Plezi::StubWSCtrl
-#    # go to: http://localhost:3000/1
-#    # =>  Plezi::StubRESTCtrl.new.show() # where params[:id] == 1
-#
-# it is possible to use "magic" routes (i.e. `/resource/:type/(:id)/(:date){/[0-9]{8}}/:foo`) and it is also possible to set the appropriate parameters within the `before` method of the Conltroller.
-#
-# Routes are handled in the order they are created. If overlapping routes exist, the first will execute first:
-#
-#    require 'plezi'
-#    route('*') do |request, response|
-#       response << "Your request, master: #{request.path}." unless request.path.match /cats/
-#    end
-#    route('*') {|request, response| response.body << "Ahhh... I love cats!"}
-#
-# The Plezi module (also `PL`) also has methods to help with asynchronous tasking, callbacks, timers and customized shutdown cleanup.
-#
-# Heres a short demo fir asynchronous callbacks (works only while services are active and running):
-#
-#    require 'plezi'
-#
-#    def my_shutdown_proc time_start
-#        puts "Services were running for #{Time.now - time_start} ms."
-#    end
-#
-#    # shutdown callbacks
-#    PL.on_shutdown(Kernel, :my_shutdown_proc, Time.now) { puts "this will run after shutdown." }
-#    PL.on_shutdown() { puts "this will run too." }
-#
-#    # a timer
-#    PL.run_after 2, -> {puts "this will wait 2 seconds to run... too late. for this example"}
-#
-#    # remember to exit to make it all start
-#    exit
-#
-# all the examples above shoold be good to run from irb. updated examples can be found at the Readme file in the Github project: https://github.com/boazsegev/plezi
-#
-# thanks to Russ Olsen for his ideas for a DSL and his blog post at:
-# http://www.jroller.com/rolsen/entry/building_a_dsl_in_ruby1 
-#
-# ...he doesn't know it, but he inspired a revolution.
-##############################################################################
-module Plezi
-end
-
-Iodine.threads = 30
-Iodine.run { puts "Plezi is feeling optimistic running version #{::Plezi::VERSION}.\n\n"}
-# PL is a shortcut for the Plezi module, so that `PL == Plezi`.
-PL = Plezi
+# def uuid
+#   @uuid ||= SecureRandom.uuid
+# end
+# def redis_channel_name
+# 		@redis_channel_name ||= "#{File.basename($0, '.*')}_redis_channel"
+# end

data/lib/plezi/activation.rb

@@ -0,0 +1,28 @@
+require 'plezi/websockets/message_dispatch' unless defined?(::Plezi::Base::MessageDispatch)
+
+module Plezi
+  protected
+
+  @plezi_finalize = nil
+  def plezi_finalize
+    if @plezi_finalize.nil?
+      @plezi_finalize = true
+      @plezi_finalize = 1
+    end
+  end
+  @plezi_initialize = nil
+  def self.plezi_initialize
+    ::Plezi::Base::MessageDispatch._init
+    if @plezi_initialize.nil?
+      @plezi_initialize = true
+      @plezi_autostart = true if @plezi_autostart.nil?
+      at_exit do
+        next if @plezi_autostart == false
+        ::Iodine::Rack.app = ::Plezi.app
+        ::Iodine.threads ||= 16
+        ::Iodine.start
+      end
+    end
+    true
+  end
+end