plezi 0.12.22 → 0.14.0

data/lib/plezi/builders/ac_model.rb

@@ -1,59 +0,0 @@
-require 'plezi/builders/builder'
-
-module Plezi
-
-	module Base
-
-
-		module ACModelBuilder
-			@gem_root = ::Plezi::Builder::GEM_ROOT
-
-			# ActiveRecord::Base.connection.tables
-			# # Checks for existence of kittens table (Kitten model)
-			# ActiveRecord::Base.connection.table_exists? 'kittens'
-
-			# # Tells you all migrations run
-			# ActiveRecord::Migrator.get_all_versions
-			# # Tells you the current schema version
-			# ActiveRecord::Migrator.current_version
-
-			# # Check a column exists
-			# column_exists?(:suppliers, :name)
-
-			# # Check a column exists of a particular type
-			# column_exists?(:suppliers, :name, :string)
-
-			# # Check a column exists with a specific definition
-			# column_exists?(:suppliers, :name, :string, limit: 100)
-			# column_exists?(:suppliers, :name, :string, default: 'default')
-			# column_exists?(:suppliers, :name, :string, null: false)
-			# column_exists?(:suppliers, :tax, :decimal, precision: 8, scale: 2)
-
-			def self.parse_args
-				return unless ARGS[0][0] == 'g'
-				struct = {}
-				ARGS[1..-1].each do |s|
-					s = s.split /[\:\.]/
-					raise "Cannot parse parameters - need to be defined as name.type or name:type." if s.count !=2
-					struct[s[0]] = DB_TYPES[s[1].downcase] || (raise "Unrecognized type #{s[1]}.")
-				end
-				struct
-			end
-		end
-
-		# require 'sequel'
-
-		# ## Connect to the database
-		# DB = Sequel.sqlite('./ex1.db')
-
-		# unless DB.table_exists? :posts
-		#   DB.create_table :posts do
-		#     primary_key :id
-		#     varchar :title
-		#     text :body
-		#   end
-		# end
-
-
-	end
-end

data/lib/plezi/builders/app_builder.rb

@@ -1,137 +0,0 @@
-require 'plezi/builders/builder'
-module Plezi
-
-	module Base
-
-		class AppBuilder
-			def initialize
-				@end_comments = []
-				@app_tree ||= {}
-				@root = ::Plezi::Base::Builder::GEM_ROOT
-			end
-			def app_tree
-				@app_tree ||= {}
-			end
-			def build_mini app_name = ARGV[1]
-				require 'plezi/version'
-				app_tree["#{app_name}"] ||= IO.read( File.join(@root, "resources" ,"mini_exec.rb")).gsub('appname', app_name)
-				app_tree["#{app_name}.rb"] ||= IO.read( File.join(@root, "resources" ,"mini_app.rb")).gsub('appname', app_name).gsub('appsecret', "#{app_name}_#{SecureRandom.hex}")
-				app_tree["Procfile"] ||= String.new
-				app_tree["Procfile"] << "\nweb: bundle exec ruby ./#{app_name} -p $PORT\n"		
-				app_tree["Gemfile"] ||= String.new
-				app_tree["Gemfile"] << "source 'https://rubygems.org'\n\n####################\n# core gems\n\n# include the basic plezi framework and server\ngem 'plezi', '~> #{Plezi::VERSION}'\n"
-				app_tree["Gemfile"] << "\n\n\nruby '#{RUBY_VERSION}'\n"
-				app_tree["rakefile"] ||= IO.read(File.join(@root,"resources" ,"rakefile")).sub('initialize.rb', "#{app_name}.rb")
-				app_tree["templates"] ||= {}
-				app_tree["templates"]["404.html.erb"] ||= IO.read(File.join(@root, "resources" ,"404.erb"))
-				app_tree["templates"]["500.html.erb"] ||= IO.read(File.join(@root, "resources" ,"500.erb"))
-				app_tree["templates"]["welcome.html.erb"] ||= IO.read(File.join(@root, "resources" ,"mini_welcome_page.html")).gsub('appname', app_name)
-				app_tree["assets"] ||= {}
-				app_tree["assets"]["websocket.js"] ||= IO.read(File.join(@root, "resources" ,"websockets.js")).gsub('appname', app_name)
-				app_tree["assets"]["plezi_client.js"] ||= IO.read(File.join(@root,"resources" ,"plezi_client.js")).gsub('appname', app_name)
-				finalize app_name
-			end
-
-			def build app_name = ARGV[1]
-				require 'plezi/version'
-				# plezi run script
-				app_tree["#{app_name}"] ||= IO.read File.join(@root,"resources" ,"code.rb")
-
-				# set up application files
-				app_tree["app"] ||= {}
-				app_tree["app"]["controllers"] ||= {}
-				app_tree["app"]["controllers"]["sample_controller.rb"] ||= IO.read(File.join(@root,"resources" ,"controller.rb"))
-				app_tree["app"]["models"] ||= {}
-				app_tree["app"]["views"] ||= {}
-
-				# set up templates for status error codes
-				app_tree["app"]["views"]["404.html"] ||= IO.read(File.join(@root,"resources" ,"404.html"))
-				app_tree["app"]["views"]["500.html"] ||= IO.read(File.join(@root,"resources" ,"500.html"))
-				app_tree["app"]["views"]["404.html.erb"] ||= IO.read(File.join(@root,"resources" ,"404.erb"))
-				app_tree["app"]["views"]["500.html.erb"] ||= IO.read(File.join(@root,"resources" ,"500.erb"))
-				app_tree["app"]["views"]["404.html.slim"] ||= IO.read(File.join(@root,"resources" ,"404.slim"))
-				app_tree["app"]["views"]["500.html.slim"] ||= IO.read(File.join(@root,"resources" ,"500.slim"))
-				app_tree["app"]["views"]["404.html.haml"] ||= IO.read(File.join(@root,"resources" ,"404.haml"))
-				app_tree["app"]["views"]["500.html.haml"] ||= IO.read(File.join(@root,"resources" ,"500.haml"))
-
-				# set up the assets folder
-				app_tree["assets"] ||= {}
-				app_tree["assets"]["stylesheets"] ||= {}
-				app_tree["assets"]["javascripts"] ||= {}
-				app_tree["assets"]["javascripts"]["websocket.js"] ||= IO.read(File.join(@root,"resources" ,"websockets.js")).gsub('appname', app_name)
-				app_tree["assets"]["javascripts"]["plezi_client.js"] ||= IO.read(File.join(@root,"resources" ,"plezi_client.js")).gsub('appname', app_name)
-				app_tree["assets"]["welcome.html"] ||= IO.read(File.join(@root,"resources" ,"welcome_page.html")).gsub('appname', app_name)
-
-				# app core files.
-				app_tree["initialize.rb"] ||= IO.read File.join(@root,"resources" ,"initialize.rb").gsub('appname', app_name)
-				app_tree["routes.rb"] ||= IO.read File.join(@root,"resources" ,"routes.rb")
-				app_tree["rakefile"] ||= IO.read File.join(@root,"resources" ,"rakefile")
-				app_tree["Procfile"] ||= ""
-				app_tree["Procfile"] << "\nweb: bundle exec ruby ./#{app_name} -p $PORT\n"
-				app_tree["Gemfile"] ||= ''
-				app_tree["Gemfile"] << "source 'https://rubygems.org'\n\n####################\n# core gems\n\n# include the basic plezi framework and server\ngem 'plezi', '~> #{Plezi::VERSION}'\n"
-				app_tree["Gemfile"] << IO.read( File.join(@root,"resources" ,"Gemfile"))
-				app_tree["Gemfile"] << "\n\n\nruby '#{RUBY_VERSION}'\n"
-
-				# set up config files
-				app_tree["initialize"] ||= {}
-				app_tree["initialize"]["oauth.rb"] ||= IO.read(File.join(@root,"resources" ,"oauth_config.rb"))
-				app_tree["initialize"]["active_record.rb"] ||= IO.read(File.join(@root,"resources" ,"db_ac_config.rb"))
-				app_tree["initialize"]["sequel.rb"] ||= IO.read(File.join(@root,"resources" ,"db_sequel_config.rb"))
-				app_tree["initialize"]["datamapper.rb"] ||= IO.read(File.join(@root,"resources" ,"db_dm_config.rb"))
-				app_tree["initialize"]["haml.rb"] ||= IO.read(File.join(@root,"resources" ,"haml_config.rb"))
-				app_tree["initialize"]["slim.rb"] ||= IO.read(File.join(@root,"resources" ,"slim_config.rb"))
-				app_tree["initialize"]["i18n.rb"] ||= IO.read(File.join(@root,"resources" ,"i18n_config.rb"))
-				app_tree["initialize"]["redis.rb"] ||= (IO.read(File.join(@root,"resources" ,"redis_config.rb"))).gsub('appsecret', "#{app_name}_#{SecureRandom.hex}")
-
-				#set up database stub folders
-				app_tree["db"] ||= {}
-				app_tree["db"]["migrate"] ||= {}
-				app_tree["db"]["fixtures"] ||= {}
-				app_tree["db"]["config.yml"] ||= IO.read(File.join(@root,"resources" ,"database.yml"))
-
-				#set up the extras folder, to be filled with future goodies.
-				# app_tree["extras"] ||= {}
-				# app_tree["extras"]["config.ru"] ||= IO.read File.join(@root,"resources" ,"config.ru")
-
-				#set up I18n stub
-				app_tree["locales"] ||= {}
-				app_tree["locales"]["en.yml"] ||= IO.read File.join(@root,"resources" ,"en.yml")
-
-				# 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"]["assets"] ||= {}		
-				app_tree["public"]["assets"]["stylesheets"] ||= {}		
-				app_tree["public"]["assets"]["javascripts"] ||= {}		
-				app_tree["public"]["images"] ||= {}
-				finalize app_name
-			end
-			def finalize app_name = ARGV[1]
-				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
-				File.chmod 0775, "#{app_name}" rescue true
-				puts "done."
-				puts "\n#{@end_comments.join("\n")}" unless @end_comments.empty?
-				puts ""
-				puts "please change directory into the app directory: cd #{app_name}"
-				puts ""
-				puts "run the #{app_name} app using: ./#{app_name} or using: plezi s"
-				puts ""
-			end
-		end
-	end
-end

data/lib/plezi/builders/builder.rb

@@ -1,43 +0,0 @@
-module Plezi
-	module Base
-		module Builder
-
-			GEM_ROOT = ::File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..'))
-
-			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.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
-	end
-
-end

data/lib/plezi/builders/form_builder.rb

@@ -1,27 +0,0 @@
-require 'plezi/builders/builder'
-
-module Plezi
-
-	module Base
-
-		module FormBuilder
-
-			FORM_BUILDERS = %w{ Slim ERB }
-			MODEL_BUILDERS = %w{ Squel }
-
-			DB_TYPES = %w{primary_key string text integer float decimal datetime time date binary boolean}
-
-			@gem_root = ::Plezi::Builder::GEM_ROOT
-			def self.parse_args
-				return unless ARGS[0][0] == 'g'
-				struct = {}
-				ARGS[1..-1].each do |s|
-					s = s.split /[\:\.]/
-					raise "Cannot parse parameters - need to be defined as name.type or name:type." if s.count !=2
-					struct[s[0]] = DB_TYPES[s[1].downcase] || (raise "Unrecognized type #{s[1]}.")
-				end
-				struct
-			end
-		end
-	end
-end

data/lib/plezi/common/api.rb

@@ -1,92 +0,0 @@
-
-module Plezi
-
-	module_function
-
-	# Defines methods used to set up the Plezi app.
-
-	# Deprecated. use {Plezi.host}.
-	def listen parameters = {}
-		Iodine.warn "listen is deprecated. use `Plezi.host` instead."
-		host parameters.delete(:host) || :default, parameters
-	end
-
-	# adds a route to the last server created
-	def route(path, controller = nil, &block)
-		if controller == :client
-			client_path = File.expand_path(File.join('..','..','..','..','resources','plezi_client.js'), __FILE__)
-			controller = nil
-			block = Proc.new {  Plezi.cache_needs_update?(client_path) ? Plezi.reload_file(client_path) : Plezi.load_file(client_path) }
-		end
-		::Plezi::Base::HTTPRouter.add_route path, controller, &block
-	end
-
-
-	# adds a shared route to all existing services and hosts.
-	def shared_route(path, controller = nil, &block)
-		::Plezi::Base::HTTPRouter.add_shared_route path, controller, &block
-	end
-
-	# public API to add or setup domain names related to the application.
-	#
-	# A default host can be created or accessed by using `:default` of false for the host name.
-	#
-	# Accepts:
-	# host_name:: (optional, can be omitted) the name (domain name) of the host as a String object. Use the Symbol `:default` for the catch-all domain name.
-	# options_hash:: see further detail.
-	# 
-	#
-	# The options is a Hash object with any of the following options (Hash keys):
-	# host:: the ost name to be used if one isn't supplied as a direct argument. Defaults to the `:default` host.
-	# alias:: a String or an Array of Strings which represent alternative host names (i.e. `alias: ["admin.google.com", "admin.gmail.com"]`).
-	# public:: the public root folder. if this is defined, static files will be served from this folder and all it's sub-folders. Plezi does NOT support file indexing.
-	# assets:: the assets root folder. defaults to nil (no assets support). if the path is defined, assets will be served from `/assets/...` (or the public_asset path defined) before any static files. assets will not be served if the file in the /public/assets folder if up to date (a rendering attempt will be made for systems that allow file writing).
-	# assets_public:: the assets public uri location (uri format, NOT a file path). defaults to `/assets`. `save_assets` will set if assets should be saved to the assets public folder as static files (defaults to false).
-	# assets_callback:: a method that accepts two parameters: (request, response) and renders any custom assets. the method should return `false` unless it had set the response.
-	# save_assets:: saves the rendered assets to the filesystem, under the public folder. defaults to false.
-	# templates:: the templates root folder. defaults to nil (no template support). templates can be rendered by a Controller class, using the `render` method.
-	#
-	# Assets:
-	#
-	# Assets support will render `.sass`, `.scss` and `.coffee` and save them as local files (`.css`, `.css`, and `.js` respectively)
-	# before sending them as static files.
-	#
-	# Should you need to render a different type of asset, you can define an assets_callback (or submit a pull request with a patch). 
-	# 
-	# templates:
-	#
-	# Plezi's controller.render ERB, Slim and Haml are natively supported.
-	#
-	# @return [::Plezi::Base::HTTPRouter]
-	#
-	def host(host_name, params = {})
-		::Plezi::Base::HTTPRouter.add_host host_name, params
-	end
-
-	# This allows you to use the Plezi framework's code inside your existing Rack application - WITHOUT running the actual server.
-	#
-	# The server will not be initiatet and instead you will be able to use Plezi controllers and the Redis auto-config
-	# to broadcast Plezi messages to other Plezi processes - allowing for scalable intigration of Plezi into existing Rack applications.
-	def start_placebo receiver = nil
-		# force start Iodine only if Iodine isn't used as the server
-		if ::Iodine.protocol == ::Iodine::Http::Http1 && (defined?(::Rack::VERSION) ? (::Rack::Handler.default == ::Iodine::Http::Rack rescue true) : true)
-			Iodine.log("* `start_placebo` Placebo directive ignored, as this seems to be the main application.\n")
-			# just initialize the receiver class (no instance) and return
-			Plezi::Placebo.new(receiver, false) if receiver
-			return false
-		end
-		unless @placebo_initialized
-			raise "Placebo fatal error: Redis connection failed to load - make sure gem is required and `ENV['PL_REDIS_URL']` is set." unless redis # make sure the redis connection is activated
-			Iodine.log "* Plezi #{Plezi::VERSION} Services will start with no Server - This is the Placebo application\n"
-			::Iodine.protocol = :no_server
-			Iodine.force_start!
-			@placebo_initialized = true
-		end
-		receiver ? Plezi::Placebo.new(receiver) : true
-	end
-
-	# deprecation notice
-	def start_rack
-		Iodine.warn "`start_rack` is deprecated. There is no need to call this method."
-	end
-end

data/lib/plezi/common/cache.rb

@@ -1,122 +0,0 @@
-
-module Plezi
-
-	# File and Object Caching for Plezi
-	#
-	# Be aware that the cache is local, per process. It's possible to limit file caching by limiting the supported_types in Plezi::Cache::CACHABLE.
-	#
-	# Template rendering engines are always cached.
-	module Cache
-		# contains the cached data, in the format: CACHE_STORE["filename"] = CacheObject
-		CACHE_STORE = {}
-		CACHE_LOCK = Mutex.new
-		CACHABLE = (%w{cache object slim haml css map js html scss sass coffee txt xml json yaml rb}).to_set
-
-		# this class holds cached objects (data and modification times)
-		class CacheObject
-			# Cached attributes
-			attr_accessor :data, :mtime
-
-			# initialize a Cached object
-			def initialize d = nil, t = Time.now
-				@data = d
-				@mtime = t
-			end
-		end
-
-		# load the file from the cache (if exists) or the file system (if it doesn't)
-		def load_file filename
-			cached?(filename) ? get_cached(filename) : reload_file(filename)
-		end
-		# review a file's modification time
-		def file_mtime filename
-			return CACHE_STORE[filename].mtime if cached?(filename)
-			File.mtime(filename)
-		end
-
-		# force a file onto the cache (only if it is cachable - otherwise will load the file but will not cache it).
-		def reload_file filename
-			if CACHABLE.include? filename.match(/\.([^\.]+)$/)[1]
-				return cache_data filename, IO.binread(filename), File.mtime(filename)
-			else
-				return IO.binread(filename)
-			end
-		end
-		# places data into the cache, and attempts to save the data to a file name.
-		def save_file filename, data, save_to_disk = false
-			cache_data filename, data if CACHABLE.include? filename.match(/\.([^\.]+)$/)[1]
-			begin
-				IO.binwrite filename, data if save_to_disk
-			rescue
-				Plezi.warn("File couldn't be written (#{filename}) - file system error?")
-			end
-			data
-		end
-
-		# places data into the cache, under an identifier ( file name ).
-		def cache_data filename, data, mtime = Iodine.time
-			CACHE_LOCK.synchronize { CACHE_STORE[filename] = CacheObject.new( data, mtime )  }
-			data
-		end
-
-		# Get data from the cache. will throw an exception if there is no data in the cache.
-		# 
-		# If a block is passed to the method, it will allows you to modify the protected cache in a thread safe manner.
-		#
-		# This is useful for manipulating strings or arrays that are stored in the cache.
-		def get_cached filename
-			return CACHE_STORE[filename].data unless block_given?
-			data = CACHE_STORE[filename].data
-			CACHE_LOCK.synchronize { yield(data) }
-		end
-
-		# Remove data from the cache, if it exists.
-		def clear_cached filename
-			CACHE_LOCK.synchronize { CACHE_STORE.delete filename } # if CACHE_STORE[filename]
-		end
-
-		# clears all cached data.
-		def clear_cache! filename
-			CACHE_LOCK.synchronize { CACHE_STORE.clear } # if CACHE_STORE[filename]
-		end
-
-		# returns true if the filename is cached.
-		def cached? filename
-			CACHE_STORE[filename] && true
-		end
-
-		# returns true if the file exists on disk or in the cache.
-		def file_exists? filename
-			( CACHE_STORE[filename] || File.exist?(filename) ) && true
-		end
-
-		# returns true if the {#allow_cache_update?} is true and the file has been update since data was last cached.
-		def cache_needs_update? filename
-			return true if CACHE_STORE[filename].nil? || (CACHE_STORE[filename].mtime < File.mtime(filename))
-			false
-		end
-
-		# # # The following was discarded because benchmarks show the difference is negligible
-		# @refresh_cache ||= (ENV['ENV'] != 'production')
-		# # get the cache refresh directive for {#cache_needs_update}. Defaults to ENV['ENV'] != 'production'
-		# def allow_cache_update?
-		# 	@refresh_cache ||= (ENV['ENV'] != 'production')
-		# end
-		# # set the cache refresh directive for {#cache_needs_update}
-		# def allow_cache_update= val
-		# 	@refresh_cache = val
-		# end
-		# # returns true if the {#allow_cache_update?} is true and the file has been update since data was last cached.
-		# def cache_needs_update? filename
-		# 	return true if CACHE_STORE[filename].nil? || (allow_cache_update? && (CACHE_STORE[filename].mtime < File.mtime(filename)))
-		# 	false
-		# end
-
-
-
-	end
-
-	public
-
-	extend Plezi::Cache
-end