plezi 0.7.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in plezi.gemspec
+gemspec

data/KNOWN_ISSUES.md

@@ -0,0 +1,13 @@
+# Known Issues
+
+Here we will list known issues and weather or not a solution is being persued.
+
+## Caching?
+
+seems caching sometimes fails ( data isn't cached / cache keeps reloading)...?
+
+## Chuncked data issues? or Apache benchmarks bug?
+
+the Apache benchmark hangs some requests, when chuncked data and missing mimetypes are introduced...
+
+is this a server or benchmark error?

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Myst
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,341 @@
+# Plezi, The Ruby Websocket and HTTP Framework
+[![Gem Version](https://badge.fury.io/rb/plezi.svg)](http://badge.fury.io/rb/plezi)
+[![Inline docs](http://inch-ci.org/github/boazsegev/plezi.svg?branch=master)](http://inch-ci.org/github/boazsegev/plezi)
+
+> People who are serious about their frameworks, should make their own servers...
+
+_(if to para-phrase "People who are serious about their software, should make their own hardware.")_
+
+## About the Plezi framework \ server
+
+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 works as an asynchronous multi-threaded Ruby alternative to a Rack/Rails/Sintra/Faye/EM-Websockets combo. It's also great as an alternative to socket.io, allowing for both websockets and long pulling.
+
+Plezi contains an object-oriented server, divided into parts that can be changed/updated and removed easily and dynamically. This allows - much like Node.js - native WebSocket support (and, if you would like to write your own Protocol or Handler, native SMPT or any other custom protocol you might wish to implement).
+
+You can follow our [tutorial to write your first Plezi Chatroom](http://boazsegev.github.io/plezi/websockets.html) - but it's better to start with this readme and explore the WebSockets example given here.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'plezi'
+```
+Or install it yourself as:
+
+    $ gem install plezi
+
+## Creating an Plezi Application
+
+to create a new barebones app using the Plezi framework, run from terminal:
+
+    $ plezi new appname
+
+That's it, now you have a ready to use basic web server (with some demo code), just run it:
+
+    $ cd appname
+    $ ./appname.rb # ( or: plezi s )
+
+now go, in your browser, to: [http://localhost:3000/](http://localhost:3000/)
+
+the default first port for the app is 3000. you can set the first port to listen to by using the `-p ` option (make sure you have permissions for the requested port):
+
+    $ ./appname.rb -p 80
+
+you now have a smart framework app that will happily eat any gem you feed it. it responds extra well to Haml, Sass and Coffee-Script, which you can enable in it's Gemfile.
+
+## Barebones Web Service
+
+this example is basic, useless, but required for every doc out there...
+
+"Hello World!" in 3 lines - try it in irb (exit irb to start server):
+
+		require 'plezi'
+		listen
+		route(/.?/) { |req, res| res << "Hello World!" }
+
+After you exited irb, the Plezi server started up. go to http://localhost:3000/ and see it run :)
+
+## Plezi Controller classes
+
+One of the best things about the Plezi is it's ability to take in any class as a controller class and route to the classes methods with special support for RESTful methods (`index`, `show`, `new`, `save`, `update`, `delete`, `before` and `after`) and for WebSockets (`pre_connect`, `on_connect`, `on_message(data)`, `on_disconnect`, `broadcast`, `collect`):
+
+        require 'plezi'
+
+        class Controller
+            def index
+                "Hello World!"
+            end
+        end
+
+        listen
+        route '*' , Controller
+
+Except for WebSockets, returning a String will automatically add the string to the response before sending the response - which makes for cleaner code. It's also possible to send the response as it is (by returning true).
+
+Controllers can even be nested (order matters) or have advanced uses that are definitly worth exploring.
+
+**please read the demo code for Plezi::StubRESTCtrl and Plezi::StubWSCtrl to learn more.**
+
+## Native Websocket and Radis support
+
+Plezi Controllers have access to native websocket support through the `pre_connect`, `on_connect`, `on_message(data)`, `on_disconnect`, `broadcast` and `collect` methods.
+
+Here is some demo code for a simple Websocket broadcasting server, where messages sent to the server will be broadcasted back to all the **other** active connections (the connection sending the message will not recieve the broadcast).
+
+As a client side, we will use the WebSockets echo demo page - we will simply put in ws://localhost:3000/ as the server, instead of the default websocket server (ws://echo.websocket.org).
+
+Remember to connect to the service from at least two browser windows - to truly experience the `broadcast`ed websocket messages.
+
+```ruby
+    require 'plezi'
+
+    # do you need automated redis support?
+    # require 'redis'
+    # ENV['PL_REDIS_URL'] = "http://user:password@localhost:6379"
+
+    class BroadcastCtrl
+        def index
+            redirect_to 'http://www.websocket.org/echo.html'
+        end
+        def on_message data
+            # try replacing the following two lines are with:
+            # self.class.broadcast :_send_message, data
+            broadcast :_send_message, data
+            response << "sent."
+        end
+        def _send_message data
+            response << data
+        end
+        def people
+            'I made this :)'
+        end
+    end
+
+    listen 
+
+    route '/', BroadcastCtrl
+```
+
+method names starting with an underscore ('_') will NOT be made public by the router: so while '/people' is public ( [try it](http://localhost:3000/people) ), '/_send_message' will return a 404 not found error ( [try it](http://localhost:3000/_send_message) ).
+
+## Native HTTP streaming with Asynchronous events
+
+Plezi comes with native HTTP streaming support, alowing you to use Plezi Events and Timers to send an Asynchronous response.
+
+Let's make the classic 'Hello World' use HTTP Streaming and Asynchronous Plezi Events:
+
+```ruby
+        require 'plezi'
+
+        class Controller
+            def index
+                response.start_http_streaming
+                PL.callback(response, :send, "Hello World") { response.finish }
+                true
+            end
+        end
+
+        listen
+        route '*' , Controller
+```
+
+Notice the easy use of Asynchronous Events using the PL#callback method. The optional block passed to this method (`response.finish`) will be executed only after the asynchronous call for the response#send method with the "Hello World" argument has completed.
+
+More on asynchronous events and timers later.
+
+## Plezi Routes
+
+Plezi supports magic routes, in similar formats found in other systems, such as: `route "/:required/(:optional_with_format){[\\d]*}/(:optional)", Plezi::StubRESTCtrl`.
+
+Plezi assummes all simple string routes to be RESTful routes woth the parameter `:id` ( `"/user" == "/user/(:id)"` ).
+
+    require 'plezi'
+    listen
+
+    # this route demos a route for listing/showing posts,
+    # with or without revision numbers or page-control....
+    # notice the single quotes (otherwise the '\' would need to be escaped).
+    route '/post/(:id)/(:revision){[\d]+\.[\d]+}/(:page_number)', Plezi::StubRESTCtrl
+
+now visit:
+
+* [http://localhost:3000/post/12/1.3/1](http://localhost:3000/post/12/1.3/1)
+* [http://localhost:3000/post/12/1](http://localhost:3000/post/12/1)
+
+**please see the `route` documentation for more information on routes**.
+
+## Plezi Virtual Hosts
+
+Plezi can be used to create virtual hosts for the same service:
+
+    require 'plezi'
+    listen
+    host 'localhost', alias: 'localhost2'
+
+    shared_route '/people' do |req, res|
+        res << "we are people - shared by all routes."
+    end
+
+    host
+
+    route('*') do |req, res|
+        res << "this is a 'catch-all' host. you got here by putting in the IP adderess."
+    end
+
+    host 'localhost'
+
+    route('*') do |req, res|
+        res << "this is localhost or localhost 2"
+    end
+
+Now visit:
+
+* [http://127.0.0.1:3000/]( http://127.0.0.1:3000/ )
+* [http://localhost:3000/]( http://localhost:3000/ )
+* [http://127.0.0.1:3000/people]( http://127.0.0.1:3000/people )
+* [http://localhost:3000/people]( http://localhost:3000/people )
+
+## Plezi Logging
+
+The Plezi module (also `PL`) has methods to help with logging as well as the support you already noticed for dynamic routes, dynamic services and more.
+
+Logging:
+
+    require 'plezi'
+
+    # simple logging of strings
+    PL.info 'log info'
+    PL.warn 'log warning'
+    PL.error 'log error'
+    PL.fatal "log a fatal error (shuoldn't be needed)."
+    PL.log_raw "Write raw strings to the logger."
+
+    # the logger accepts exceptions as well.
+    begin
+        raise "hell"
+    rescue Exception => e
+        PL.error e
+    end
+
+## Plezi Events and Timers
+
+The Plezi module (also `PL`) also has methods to help with asynchronous tasking, callbacks, timers and customized shutdown cleanup.
+
+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"}
+
+    # an asynchronous method call with an optional callback block
+    PL.callback(Kernel, :puts, "Plezi will start eating our code once we exit terminal.") {puts 'first output finished'}
+
+## Food for thought - advanced controller uses
+
+Here's some food for thought - code similar to something actually used at some point while developing the applicatio template used by `plezi new myapp`:
+
+    require 'plezi'
+
+    # this controller will re-write the request to extract data,
+    # and then it will fail, so that routing continues.
+    #
+    # this is here just for the demo.
+    #
+    class ReWriteController
+        # using the before filter and regular expressions to make some changes.
+        def before
+            # extract the fr and en locales.
+            result = request.path.match /^\/(en|fr)($|\/.*)/
+
+            if result
+                params[:locale] = result[1]
+                request.path = result[2]
+            end
+
+            # let the routing continue.
+            return false
+        end
+    end
+
+    class Controller
+        def index
+            return "Bonjour le monde!" if params[:locale] == 'fr'
+            "Hello World!\n #{params}"
+        end
+        def show
+            return "Vous êtes à la recherche d' : #{params[:id]}" if params[:locale] == 'fr'
+            "You're looking for: #{params[:id]}"
+        end
+        def debug
+            # binding.pry
+            # do you use pry for debuging?
+            # no? oh well, let's ignore this.
+            false
+        end
+        def delete
+            return "Mon Dieu! Mon français est mauvais!" if params[:locale] == 'fr'
+            "did you try /#{params["id"]}/?_method=delete or does your server support a native DELETE method?"
+        end
+    end
+
+    listen
+
+    # we run the ReWriteController first, to rewrite the path for all the remaining routes.
+    #
+    # this is here just for the demo...
+    #
+    # ...in this specific case, it is possible to dispense with the ReWriteController class
+    # and write:
+    #
+    # route '/(:locale){fr|en}/*', false
+    #
+    # the false controller acts as a simple path re-write that
+    # deletes everything before the '*' sign (the catch-all).
+    #
+    route '*' , ReWriteController
+
+    # this route takes a regular expression that is a simple math calculation
+    # (calculator)
+    route /^\/[\d\+\-\*\/\(\)\.]+$/ do |request, response|
+        message = (request.params[:locale] == 'fr') ? "La solution est" : "My Answer is"
+        response << "#{message}: #{eval(request.path[1..-1])}"
+    end
+
+    route "/users" , Controller
+
+    route "/" , Controller
+
+try:
+
+* [http://localhost:3000/](http://localhost:3000/)
+* [http://localhost:3000/fr](http://localhost:3000/fr)
+* [http://localhost:3000/users/hello](http://localhost:3000/users/hello)
+* [http://localhost:3000/(5+5*20-15)/9](http://localhost:3000/(5+5*20-15)/9)
+* [http://localhost:3000/fr/(5+5*20-15)/9](http://localhost:3000/fr/(5+5*20-15)/9)
+* [http://localhost:3000/users/hello?_method=delete](http://localhost:3000/users/hello?_method=delete)
+
+## Plezi Settings
+
+Plezi is ment to be very flexible. please take a look at the Plezi Module for settings you might want to play with (max_threads, idle_sleep, create_logger) or any monkey patching you might enjoy.
+
+Feel free to fork or contribute. right now I am one person, but together we can make something exciting that will help us enjoy Ruby in this brave new world and (hopefully) set an example that will induce progress in the popular mainstream frameworks such as Rails and Sinatra.
+
+## Contributing
+
+1. Fork it ( https://github.com/boazsegev/plezi-server/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/TODO.md

@@ -0,0 +1,19 @@
+# HTTPHost
+
+Folder Listing:: add folder listing option?
+
+# Template
+
+update gem file (remove erb).
+
+# Name?
+
+rename the project?
+
+# HTTPProtocol
+
+XML::
+support for XML HTTP body types?
+
+Charset::
+parse chareset for incoming content-type in the multipart request body? (or leave if binary?)

data/bin/plezi

@@ -0,0 +1,301 @@
+#!/usr/bin/env ruby
+$0="Plezi Builder"
+# count lines of code with: ^[ \t]*[\w\d\"\(\{\@\[\]\}\)\:\'\.\*\&]+.*$
+
+require 'irb'
+require 'securerandom'
+
+##########
+# this is the template writer
+#
+# you can update it by aliasing the old initialize and writing adding to it:
+#
+#		if defined? BUILDING_PLEZI_TEMPLATE
+#			class AppTemplate
+#				alias :my_new_gem_old_init :initialize
+#				def initialize
+#					# start with the old initialize, to set the template up
+#					my_new_gem_old_init appname
+#					# add your gem to the gemfile
+#					app_tree["Gemfile"] << "\n# feed GEMNAME to plezi"
+#					app_tree["Gemfile"] << "\ngem 'GEMNAME'"
+#					# make sure your folder exists, but don't overwrite!!!
+#					# if you overwrite!!! you might destroy other gems additions.
+#					app_tree["lib"] ||= {}
+#					app_tree["MY_SPECIAL_GEM"] ||= {}
+#					# once your folder exists, create your file
+#					app_tree["lib]["MY_SPECIAL_GEM"]["filename.rb"] = "# code goes here..."
+#					app_tree["file_without_folder.rb"] ||= "# more code goes here..."
+#				end
+#			end
+#		end
+#
+class AppTemplate
+
+	def initialize
+		require 'rubygems'
+		# set end comments
+		@end_comments = []
+		@app_tree ||= {}
+
+		# set up application files
+		app_tree["app"] ||= {}
+		app_tree["app"]["controllers"] ||= {}
+		app_tree["app"]["controllers"]["sample_controller.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"controller.rb"),  __FILE__))
+		app_tree["app"]["models"] ||= {}
+		app_tree["app"]["views"] ||= {}
+
+		# set up the assets folder
+		app_tree["assets"] ||= {}
+		app_tree["assets"]["stylesheets"] ||= {}
+		app_tree["assets"]["javascripts"] ||= {}
+		app_tree["assets"]["welcome.html"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"welcome_page.html"),  __FILE__)).gsub('appname', ARGV[1])
+
+		# app core files.
+		app_tree["environment.rb"] ||= IO.read ::File.expand_path(File.join("..", "..", "resources" ,"environment.rb"),  __FILE__)
+		app_tree["routes.rb"] ||= IO.read ::File.expand_path(File.join("..", "..", "resources" ,"routes.rb"),  __FILE__)
+		app_tree["rakefile.rb"] ||= IO.read ::File.expand_path(File.join("..", "..", "resources" ,"rakefile.rb"),  __FILE__)
+		app_tree["Procfile"] ||= ""
+		app_tree["Procfile"] << "\nweb: bundle exec ./#{ARGV[1]}.rb -p $PORT\n"
+		app_tree["Gemfile"] ||= IO.read ::File.expand_path(File.join("..", "..", "resources" ,"Gemfile"),  __FILE__)
+
+		# set up config files
+		app_tree["config"] ||= {}
+		app_tree["config"]["db_ac_config.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_ac_config.rb"),  __FILE__))
+		app_tree["config"]["db_sequel_config.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_sequel_config.rb"),  __FILE__))
+		app_tree["config"]["db_dm_config.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_dm_config.rb"),  __FILE__))
+		app_tree["config"]["haml_config.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"haml_config.rb"),  __FILE__))
+		app_tree["config"]["i18n_config.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"i18n_config.rb"),  __FILE__))
+		app_tree["config"]["redis_config.rb"] ||= (IO.read(::File.expand_path(File.join("..", "..", "resources" ,"redis_config.rb"),  __FILE__))).gsub('appsecret', "#{ARGV[1]}_#{SecureRandom.hex}")
+
+		#set up database stub folders
+		app_tree["db"] ||= {}
+		app_tree["db"]["migrate"] ||= {}
+
+		#set up the extras folder, to be filled with future goodies.
+		app_tree["extras"] ||= {}
+		app_tree["extras"]["config.ru"] ||= IO.read ::File.expand_path(File.join("..", "..", "resources" ,"config.ru"),  __FILE__)
+
+		#set up I18n stub
+		app_tree["locales"] ||= {}
+		app_tree["locales"]["en.yml"] ||= IO.read ::File.expand_path(File.join("..", "..", "resources" ,"en.yml"),  __FILE__)
+
+		# create library, log and tmp folders
+		app_tree["logs"] ||= {}
+		app_tree["lib"] ||= {}
+		app_tree["tmp"] ||= {}
+
+
+		# set up a public folder for static file service
+		app_tree["public"] ||= {}		
+		app_tree["public"]["404.slim"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"404.slim"),  __FILE__))
+		app_tree["public"]["500.slim"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"500.slim"),  __FILE__))
+		app_tree["public"]["404.html"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"404.html"),  __FILE__))
+		app_tree["public"]["500.html"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"500.html"),  __FILE__))
+		app_tree["public"]["404.erb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"404.erb"),  __FILE__))
+		app_tree["public"]["500.erb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"500.erb"),  __FILE__))
+		app_tree["public"]["404.haml"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"404.haml"),  __FILE__))
+		app_tree["public"]["500.haml"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"500.haml"),  __FILE__))
+		app_tree["public"]["assets"] ||= {}		
+		app_tree["public"]["assets"]["stylesheets"] ||= {}		
+		app_tree["public"]["assets"]["javascripts"] ||= {}		
+		app_tree["public"]["images"] ||= {}		
+		app_tree["public"]["images"]['plezi_gray.png'] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"plezi_gray.png"),  __FILE__))	
+
+	end
+
+	def app_tree
+		@app_tree ||= {}
+	end
+	def build
+		# require 'pry'
+		# binding.pry
+		app_tree["Gemfile"] << "\n\n\nruby '#{RUBY_VERSION}'\n"
+		begin
+			Dir.mkdir ARGV[1]
+			puts "created the #{ARGV[1]} application directory.".green
+		rescue Exception => e
+			puts "the #{ARGV[1]} application directory exists - trying to rebuild (no overwrite).".pink
+		end
+		Dir.chdir ARGV[1]
+		puts "starting to write template data...".red
+		puts ""
+		@app_tree["#{ARGV[1]}"] ||= IO.read ::File.expand_path(File.join("..", "..", "resources" ,"code.rb"),  __FILE__)
+		write_files app_tree
+		File.chmod 0775, "#{ARGV[1]}"
+		puts "tried to update execution permissions. this probably failed.".pink
+		puts "use: chmod +x ./#{ARGV[1]} to set execution permissions on Unix machines."
+		puts ""
+		puts "done."
+		puts "\n#{@end_comments.join("\n")}" unless @end_comments.empty?
+		puts ""
+		puts "please change directory into the app directory: cd #{ARGV[1]}"
+		puts ""
+		puts "run the #{ARGV[1]} app using: ./#{ARGV[1]} or using: plezi s"
+		puts ""
+	end
+
+	def 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 Exception => e
+						puts "    exists #{parent}/#{k}".red
+					end
+					Dir.chdir k
+					write_files v, (parent + "/" + k)
+					Dir.chdir ".."
+				elsif v.is_a? String
+					if ::File.exists? k
+						if false #%w{Gemfile rakefile.rb}.include? k
+							# old = IO.read k
+							# old = (old.lines.map {|l| "\##{l}"}).join
+							# IO.write k, "#####################\n#\n# OLD DATA COMMENTED OUT - PLEASE REVIEW\n#\n##{old}\n#{v}"
+							# puts "    #{parent}/#{k} WAS OVERWRITTEN, old data was preserved by comenting it out.".pink
+							# puts "    #{parent}/#{k} PLEASE REVIEW.".pink
+							# @end_comments << "#{parent}/#{k} WAS OVERWRITTEN, old data was preserved by comenting it out. PLEASE REVIEW."
+						else
+							puts "    EXISTS(!) #{parent}/#{k}".red
+						end
+					else
+						IO.write k, v
+						puts "    wrote #{parent}/#{k}".yellow
+					end
+				end
+			end
+		end
+	end
+end
+
+
+######################################################################
+# 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
+##
+######################################################################
+######################################################################
+
+if ARGV[0] == 'new' || ARGV[0] == 'n' || ARGV[0] == "force"
+	#########
+	## set up building environment
+	BUILDING_PLEZI_TEMPLATE = true
+	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
+
+	if ARGV.count > 3 && (ARGV[2] == 'with' || ARGV[2] == 'w')
+
+		# gem loading
+		local_gems = Gem::Specification.map {|g| g.name}
+		# this will load all requested gems and allow them to update the AppTemplate
+		if ARGV[3] == "all"
+			puts "loading gems and giving each gem a chance to update the app template:".yellow
+			local_gems.each do |g|
+				begin
+					puts "loaded the #{g} gem."	if require g				
+				rescue Exception => e
+					puts "couldn't load the #{g} gem... moving on.".red
+				end
+			end
+		else
+			require 'pathname'
+			ARGV[3..-1].each do |g|
+				if local_gems.include? g
+					require g
+					puts "loaded the #{g} gem, and gave it a change to update the template."
+				else
+					puts "Error, the gem: #{g} could not be found!".red
+					puts "try first running: gem install #{g}".green
+					exit
+				end
+			end
+		end
+		true
+	end
+
+	# building
+	template = AppTemplate.new
+	template.build
+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 + '.rb') ) )
+elsif ARGV[0] == 'console' || ARGV[0] == 'c'
+	NO_PLEZI_AUTO_START ||= true
+	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 + '.rb') ) )
+	ARGV.clear
+	IRB.setup nil
+	IRB.conf[:MAIN_CONTEXT] = IRB::Irb.new.context
+	require 'irb/ext/multi-irb'
+	IRB.irb nil, self
+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 "new app with gem        'new' accepts the 'with' paramater (or w for short)."
+	puts "starting up an app:".pink
+	puts "start                   runs the app. accepts any paramaters the app supports."
+	puts "s                       alias for start/server."
+	puts "start console innsead of services:".pink
+	puts "console                 runs the app. accepts any paramaters the app supports."
+	puts "c                       alias for start/server."
+	puts "==============================".green
+	puts "create an app with specific plugins:".pink
+	puts "plezi new app with gem1 gem2"
+	puts "loads the specific gem(s) and allows them to update the template before building the app.".green
+	puts ""
+	puts "create an app with ALL plugins:".pink
+	puts "plezi n app w all"
+	puts "loads the all available gem(s) and allows them to update the template before building the app.".green
+	puts ""
+	puts "start the application with any paramaters it supports:".pink
+	puts "plezi s -p 80"
+	puts "loads the app with paramaters -p 80".green
+	puts ""
+end
+
+
+