plezi 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d2c1ce05a4f21add0356e4feb915c3f559ac29b7
-  data.tar.gz: 949097175113449016158060ae646d3b94124469
+  metadata.gz: e7b74f28a320e2558c0478929989d9904ed191aa
+  data.tar.gz: 3231b1fca07d1ac55bfd14f1eff40be0cb0a7154
 SHA512:
-  metadata.gz: 60e319eb716785ff1363ded7fa6aa8a2d8e81da7239598c3ce17bab2bcb996ecda364b15ccac56b0bf1f66c260b1018a4cf04cd1249647220dd113b17868247d
-  data.tar.gz: 694bc16bb7c79cc83a90e77a6ef0880769e1a22d70d48656367592731a6aaa0f0ad4a5d1048691fba23c5ed66283403c18ade96639bfe96ce9fe11d2651cace8
+  metadata.gz: bd7d3987c60cad451d7860296ece6fc2e19b24922c318a344fde248832d7bd7b91f956db0c6f600ccca185d7bb43401973036a79b4a8f8c405b08ce9a2a524f7
+  data.tar.gz: 5ca2c5850793f1c23ddec678499989e2166062c9b4c67ae1deb2232eaa9db0069235bfaaad7482aff4728dc2ffaba59012f4ab8e0c22d278f5d7bdb44e807c1a

data/CHANGELOG.md

@@ -2,11 +2,21 @@
 
 ***
 
+Change log v.0.7.4
+
+**change/fix**: it seems that behavior is more predictable when routes macgic parameters are non-persistent between routes. The old behavior (persistent parameters) is now limited to re-write routes.
+
+**fix**: an error was introduced when using paramd\[:id] with a Fixnum. This was caused by the router attempting to search for a method by that name before using the parameter as an :id. This is now fixed by temporarily converting the Fixnum to a string before the required converstion to a symbol.
+
+**experimental feature**: added the method `def_special_method`, which can be used in controller classes to create specially named paths, defying Ruby naming restrictions, such as: "play-now", "text.me" etc'. This is an EXPERIMENTAL feature which might be limited in future releases (specifically limited to names without dots '.', in case of future formatting support).
+
+***
+
 Change log v.0.7.3
 
 **major fix**: Fixed a conflict in the controller namespaces and caching system, which caused routing and Redis connection errors. The errors were resolved by moving the caching to the Framework's global caching system.
 
-**fix + feature**: It is now possible to dynamically add or remove routes from existing controllers. As you know, Plezi controllers behave like "smart folders" and their public methods are automatically published as routes. But - That routing tables is cached. Now the cache is automatically reset whenever a method is added or removed from the controller, or, you can reset the controller's routing cache by calling the controller class method #reset_routing_cache. This allows you to dynamically add or remove routes from existing controllers.
+**fix + feature**: It is now possible to dynamically add or remove routes from existing controllers. As you know, Plezi controllers behave like "smart folders" and their public methods are automatically published as routes. But - That routing table is cached. Now the cache is automatically reset whenever a method is added or removed from the controller, or, you can reset the controller's routing cache by calling the controller class method #reset_routing_cache. This allows you to dynamically add or remove routes from existing controllers.
 
 **fix**: fixed as issue with utf-8 data in the cookie and flash data, where utf-8 data wasn't encoded properly as an ASCII string before being sent in the HTTP headers.
 

data/README.md

@@ -1,4 +1,4 @@
-# Plezi, The Rack Free Ruby HTTP & Websocket Framework
+# Plezi, The Rack Free Ruby framework for realtime web-apps
 [![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)
 
@@ -94,7 +94,7 @@ Remember to connect to the service from at least two browser windows - to truly
 
     # do you need automated redis support?
     # require 'redis'
-    # ENV['PL_REDIS_URL'] = "http://user:password@localhost:6379"
+    # ENV['PL_REDIS_URL'] = "redis://user:password@localhost:6379"
 
     class BroadcastCtrl
         def index
@@ -109,7 +109,10 @@ Remember to connect to the service from at least two browser windows - to truly
         def _send_message data
             response << data
         end
-        def people
+        def hello
+            'Hello!'
+        end
+        def_special_method "humans.txt" do
             'I made this :)'
         end
     end
@@ -119,7 +122,7 @@ Remember to connect to the service from at least two browser windows - to truly
     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) ).
+method names starting with an underscore ('_') will NOT be made public by the router: so while both '/hello' and '/humans.txt' are public ( [try it](http://localhost:3000/humans.txt) ), '/_send_message' will return a 404 not found error ( [try it](http://localhost:3000/_send_message) ).
 
 ## Native HTTP streaming with Asynchronous events
 
@@ -175,7 +178,7 @@ Plezi can be used to create virtual hosts for the same service:
     listen
     host 'localhost', alias: 'localhost2'
 
-    shared_route '/people' do |req, res|
+    shared_route '/humans.txt' do |req, res|
         res << "we are people - shared by all routes."
     end
 
@@ -195,8 +198,8 @@ 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 )
+* [http://127.0.0.1:3000/humans.txt]( http://127.0.0.1:3000/humans.txt )
+* [http://localhost:3000/humans.txt]( http://localhost:3000/humans.txt )
 
 ## Plezi Logging
 
@@ -242,32 +245,19 @@ Asynchronous callbacks (works only while services are active and running):
     # 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
+## Re-write Routes
 
-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`:
+Plezi supports special routes used to re-write the request and extract parameters for all future routes.
 
-    require 'plezi'
+This allows you to create path prefixes which will be removed once their information is extracted.
 
-    # 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
+This is great for setting global information such as internationalization (I18n) locales.
 
-            # let the routing continue.
-            return false
-        end
-    end
+By using a route with the a 'false' controller, the parameters extracted are automatically retained.
+
+*(Older versions of Plezi allowed this behavior for all routes, but it was deprecated starting version 0.7.4).
+
+    require 'plezi'
 
     class Controller
         def index
@@ -286,31 +276,23 @@ Here's some food for thought - code similar to something actually used at some p
         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?"
+            "did you try #{request.base_url + request.original_path}?_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 is our re-write route.
+    # it will extract the locale and re-write the request.
+    route '/:locale{fr|en}/*', false
 
     # this route takes a regular expression that is a simple math calculation
     # (calculator)
+    #
+    # it is an example for a Proc controller, which can replace the Class controller.
     route /^\/[\d\+\-\*\/\(\)\.]+$/ do |request, response|
         message = (request.params[:locale] == 'fr') ? "La solution est" : "My Answer is"
-        response << "#{message}: #{eval(request.path[1..-1])}"
+        response << "#{message}: #{eval( request.path[1..-1] )}"
     end
 
     route "/users" , Controller
@@ -322,10 +304,15 @@ 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/(5+5*20-15)/9.0](http://localhost:3000/users/(5+5*20-15)/9.0)
+* [http://localhost:3000/(5+5*20-15)/9.0](http://localhost:3000/(5+5*20-15)/9)
+* [http://localhost:3000/fr/(5+5*20-15)/9.0](http://localhost:3000/fr/(5+5*20-15)/9)
 * [http://localhost:3000/users/hello?_method=delete](http://localhost:3000/users/hello?_method=delete)
 
+As you can see in the example above, Plezi supports Proc routes as well as Class controller routes.
+
+Please notice that there are some differences between the two. Proc routes less friedly, but plenty powerful and are great for custom 404 error handling.
+
 ## 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.

data/lib/plezi.rb

@@ -120,6 +120,8 @@ end
 #
 # 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

data/lib/plezi/base/cache.rb

@@ -66,6 +66,11 @@ module Plezi
 		LOCK.synchronize { CACHE_STORE.delete filename } # if CACHE_STORE[filename]
 	end
 
+	# clears all cached data.
+	def clear_cache! filename
+		LOCK.synchronize { CACHE_STORE.clear } # if CACHE_STORE[filename]
+	end
+
 	# returns true if the filename is cached.
 	def cached? filename
 		!CACHE_STORE[filename].nil?

data/lib/plezi/base/dsl.rb

@@ -153,6 +153,19 @@ def shared_route(path, controller = nil, &block)
 	Plezi::DSL.shared_route(path, controller, &block)
 end
 
+# defines a method with a special name, such as "humens.txt".
+#
+# this could be used in controller classes, to define special routes which might defy
+# normal Ruby naming conventions, such as "/welcome-home", "/play!", etc'
+#
+# could also be used to define methods with special formatting, such as "humans.txt",
+# until a more refined way to deal with formatting will be implemented.
+def def_special_method name, obj=self, &block
+	obj.instance_eval { define_method name.to_s.to_sym, &block }
+end
+
+
+
 # finishes setup of the servers and starts them up. This will hange the proceess.
 #
 # this method is called automatically by the Plezi framework.
@@ -170,8 +183,17 @@ def start_services
 	Plezi.start_services
 end
 
+# restarts the Plezi app with the same arguments as when it was started.
+#
+# EXPERIMENTAL
+def restart_plezi_app
+	exec "/usr/bin/env ruby #{$PL_SCRIPT} #{$PL_ARGV.join ' '}"
+end
+
 # sets to start the services once dsl script is finished loading.
 at_exit { start_services } unless ( defined?(NO_PLEZI_AUTO_START) || defined?(BUILDING_PLEZI_TEMPLATE) || defined?(PLEZI_ON_RACK) )
 
 # sets a name for the process (on some systems).
+$PL_SCRIPT = $0
+$PL_ARGV = $*.dup
 $0="Plezi (Ruby)"

data/lib/plezi/base/engine.rb

@@ -37,6 +37,7 @@ module Plezi
 		run_every(5 , Plezi.method(:clear_connections)) #{info "Cleared inactive Connections"}
 		run_every 3600 , GC.method(:start)
 		# run_every( 1 , Proc.new() { Plezi.info "#{IO_CONNECTION_DIC.length} active connections ( #{ IO_CONNECTION_DIC.select{|k,v| v.protocol.is_a?(WSProtocol)} .length } websockets)." })
+		# run_every 10 , -> {Plezi.info "Cache report: #{CACHE_STORE.length} objects cached." } 
 		(max_threads).times {  Thread.new { thread_cycle until exit_flag }  }		
 
 		# Thread.new { check_connections until SERVICES.empty? }

data/lib/plezi/handlers/controller_magic.rb

@@ -131,11 +131,11 @@ module Plezi
 				true
 			end
 
-			# renders a template file (.erb/.haml) or an html file (.html) to text
-			# for example, to render the file `body.html.haml` with the layout `main_layout.html.haml`:
+			# renders a template file (.slim/.erb/.haml) or an html file (.html) to text
+			# for example, to render the file `body.html.slim` with the layout `main_layout.html.haml`:
 			#   render :body, layout: :main_layout
 			#
-			# or, for example, to render the file `json.js.haml`
+			# or, for example, to render the file `json.js.slim`
 			#   render :json, type: 'js'
 			#
 			# or, for example, to render the file `template.haml`
@@ -148,7 +148,7 @@ module Plezi
 			# options aceept the following keys:
 			# type:: the types for the `:layout' and 'template'. can be any extention, such as `"json"`. defaults to `"html"`.
 			# layout:: a layout template that has at least one `yield` statement where the template will be rendered.
-			# locale:: the I18n locale for the render. (defaults to params[:locale]) - only if the I18n gem namespace is defined (`require 'i18n'`).
+			# locale:: the I18n locale for the render. (defaults to params\[:locale]) - only if the I18n gem namespace is defined (`require 'i18n'`).
 			#
 			# if template is a string, it will assume the string is an
 			# absolute path to a template file. it will NOT search for the template but might raise exceptions.
@@ -193,7 +193,7 @@ module Plezi
 				# set DELETE method if simulated
 				request.request_method = 'DELETE' if params[:_method].to_s.downcase == 'delete'
 				# respond to special :id routing
-				return params[:id].to_sym if params[:id] && self.class.available_public_methods.include?(params[:id].to_sym)
+				return params[:id].to_s.to_sym if params[:id] && self.class.available_public_methods.include?(params[:id].to_s.to_sym)
 				#review general cases
 				case request.request_method
 				when 'GET', 'HEAD'
@@ -302,7 +302,11 @@ module Plezi
 			
 			# reviews the Redis connection, sets it up if it's missing and returns the Redis connection.
 			#
-			# todo: review thread status? (incase an exception killed it)
+			# a Redis connection will be automatically created if the `ENV['PL_REDIS_URL']` is set.
+			# for example:
+			#      ENV['PL_REDIS_URL'] = ENV['REDISCLOUD_URL']`
+			# or
+			#      ENV['PL_REDIS_URL'] = "redis://username:password@my.host:6379"
 			def redis_connection
 				# return false unless defined?(Redis) && ENV['PL_REDIS_URL']
 				# return @@redis if defined?(@@redis_sub_thread) && @@redis

data/lib/plezi/handlers/route.rb

@@ -16,6 +16,7 @@ module Plezi
 		def on_request request
 			fill_parameters = match request.path
 			return false unless fill_parameters
+			old_params = request.params.dup
 			fill_parameters.each {|k,v| HTTP.add_param_to_hash k, v, request.params }
 			ret = false
 			response = HTTPResponse.new request
@@ -29,7 +30,7 @@ module Plezi
 				return false
 			end
 			unless ret
-				request.params.delete :id if fill_parameters['id']
+				request.params.replace old_params unless fill_parameters.empty?
 				return false
 			end
 			response.try_finish

data/lib/plezi/server/protocols/http_protocol.rb

@@ -180,6 +180,12 @@ module Plezi
 			@parser_data[:path] = @parser_data[:original_path].chomp('/')
 			@parser_data[:original_path].freeze
 
+			# the following can be used to extract the request's 'format':
+			# /(^.*)(\.[^\.\/]*)$/.match @parser_data[:path]
+			# ...? should this be done? Could be limited to certain formats:
+			#  /(^.*)(\.(txt|html|json|js|xml|xhtml|csv))$/.match @parser_data[:path]
+			# ... even worst?
+
 			HTTP.make_utf8! @parser_data[:host_name] if @parser_data[:host_name]
 			HTTP.make_utf8! @parser_data[:query]
 

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-    VERSION = "0.7.3"
+    VERSION = "0.7.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plezi
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-20 00:00:00.000000000 Z
+date: 2015-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler