plezi 0.12.22 → 0.14.0

data/lib/plezi/controller/cookies.rb

@@ -0,0 +1,40 @@
+module Plezi
+  module Controller
+    # The cookie jar class. Controllers have an instance of this class named `cookies`.
+    class Cookies < Hash
+      attr_reader :request, :response
+      def initialize(request, response)
+        @request = request
+        @response = response
+      end
+
+      # Reads a cookie from either the request cookie Hash or the new cookies Hash.
+      def[](key)
+        if key.is_a? Symbol
+          super(key) || super(key.to_s) || @request.cookies[key] || @request.cookies[key.to_s]
+        elsif key.is_a? String
+          super(key) || super(key.to_sym) || @request.cookies[key] || @request.cookies[key.to_sym]
+        else
+          super(key) || @request.cookies[key]
+        end
+      end
+
+      # Sets (or deletes) a cookie. New cookies are placed in the new cookie Hash and are accessible only to the controller that created them.
+      def[]=(key, value)
+        if value.nil?
+          @response.delete_cookie key
+          delete key
+          if key.is_a? Symbol
+            delete key.to_s
+          elsif key.is_a? String
+            delete key.to_sym
+          end
+          return nil
+        end
+        @response.set_cookie key, value
+        value = value[:value] if value.is_a? Hash
+        super
+      end
+    end
+  end
+end

data/lib/plezi/helpers.rb

@@ -0,0 +1,60 @@
+require 'plezi/activation'
+require 'plezi/router/router'
+
+module Plezi
+  module_function
+
+  # attempts to convert a string's encoding to UTF-8, but only when the string is a valid UTF-8 encoded string.
+  def try_utf8!(string, encoding = ::Encoding::UTF_8)
+    return nil unless string
+    string.force_encoding(::Encoding::ASCII_8BIT) unless string.force_encoding(encoding).valid_encoding?
+    string
+  end
+
+  # Sanitizes hash data, attempting to "rubyfy" any Hash Strings to reversible Ruby objects. i.e:
+  #
+  #          {"go" => "<tag>home</tag>", "now" => "false", "count" => "8", "float" => "0.7", "empty" => ""}
+  #
+  # Will become:
+  #
+  #          {go: "&lt;tag>home&lt;/tag&gt;", now: false, count: 8, float: "0.7", empty: nil}
+  #
+  # As you may notice, float Strings aren't "rubyfied". Any "rubyfied" object will revert back to the same String form using `to_s`.
+  def rubyfy(hash)
+    case hash
+    when Hash
+      cpy = Hash.new(&hash_proc_4symstr)
+      hash.each { |k, v| cpy[k.is_a?(String) ? k.to_sym : k] = rubyfy(v) }
+      hash = cpy
+    when String
+      hash = if hash.empty?
+               nil
+             elsif hash.to_i.to_s == hash
+               hash.to_i
+             elsif hash == 'true'.freeze
+               true
+             elsif hash == 'false'.freeze
+               false
+             else
+               ERB::Util.h try_utf8!(hash)
+             end
+    when Array
+      hash = hash.map { |i| rubyfy(i) }
+    end
+    hash
+  end
+
+  # Catches String/Symbol mixups. Add this to any Hash using Hash#default_proc=
+  def hash_proc_4symstr
+    @hash_proc_4symstr ||= proc do |hash, key|
+      case key
+      when String
+        tmp = key.to_sym
+        hash.key?(tmp) ? hash[tmp] : nil
+      when Symbol
+        tmp = key.to_s
+        hash.key?(tmp) ? hash[tmp] : nil
+      end
+    end
+  end
+end

data/lib/plezi/rake.rb

@@ -1,24 +1,2 @@
-# make sure this file only runs within the context of a Rake enabled script
-if defined? Rake
-	
-	# Make sure the server doesn't start
-	Iodine.protocol = false
-
-
-	namespace :make do
-		# TODO: add ActiveRecord controller-model generator
-
-		# TODO: add Squel controller-model generator
-
-	end
-	# add console mode
-	desc "Same as `plezi c`: starts the application as a console, NOT a server."
-	task :console do
-		Kernel.exec "plezi c"
-	end
-	desc "Same as `rake console`: starts the application as a console, NOT a server."
-	task :c do
-		Kernel.exec "plezi c"
-	end
-
-end
+require 'plezi'
+Plezi.no_autostart

data/lib/plezi/render/erb.rb

@@ -0,0 +1,34 @@
+require 'plezi/render/has_cache' unless defined? ::Plezi::Base::HasStore
+require 'erb'
+module Plezi
+  module Base
+    module RenderERB
+      extend ::Plezi::Base::HasStore
+
+      module_function
+
+      def call(filename, context, &block)
+        return unless defined? ::ERB
+        return unless File.exist?(filename)
+        engine = load_engine(filename)
+        engine.result(context, &block)
+      end
+      if ENV['RACK_ENV'.freeze] == 'production'.freeze
+        def load_engine(filename)
+          engine = self[filename]
+          return engine if engine
+          self[filename] = ::ERB.new(::Plezi.try_utf8!(IO.binread(filename)))
+        end
+      else
+        def load_engine(filename)
+          engine, tm = self[filename]
+          return engine if engine && (tm == File.mtime(filename))
+          self[filename] = [(engine = ::ERB.new(::Plezi.try_utf8!(IO.binread(filename)))), File.mtime(filename)]
+          engine
+        end
+      end
+    end
+  end
+end
+
+::Plezi::Renderer.register :erb, ::Plezi::Base::RenderERB

data/lib/plezi/render/has_cache.rb

@@ -0,0 +1,36 @@
+module Plezi
+  module Base
+    # Provides a thread-safe caching engine
+    module HasCache
+      # initializes the cache
+      def self.extended(base)
+        base.instance_variable_set :@_lock, Mutex.new
+        base.instance_variable_set :@_cache, {}.dup
+      end
+
+      # Stores data in the cache
+      def store(key, value)
+        @_lock.synchronize { @_cache[key] = value }
+      end
+      alias []= store
+      # Retrieves data form the cache
+      def get(key)
+        @_lock.synchronize { @_cache[key] }
+      end
+      alias [] get
+    end
+    # Provides thread-specific caching engine, allowing lockless cache at the expenss of memory.
+    module HasStore
+      # Stores data in the cache
+      def store(key, value)
+        (Thread.current[(@_chache_name ||= object_id.to_s(16))] ||= {}.dup)[key] = value
+      end
+      alias []= store
+      # Retrieves data form the cache
+      def get(key)
+        (Thread.current[(@_chache_name ||= object_id.to_s(16))] ||= {}.dup)[key]
+      end
+      alias [] get
+    end
+  end
+end

data/lib/plezi/render/markdown.rb

@@ -0,0 +1,63 @@
+require 'plezi/render/has_cache' unless defined? ::Plezi::Base::HasStore
+# Redcarpet might not be available, if so, allow the require to throw it's exception.
+unless defined?(::Redcarpet::Markdown)
+  begin
+    require('redcarpet')
+  rescue Exception
+
+  end
+end
+
+if defined?(Redcarpet::Markdown)
+  module Plezi
+    module Base
+      module RenderMarkDown
+        # A custom render engine that makes sure links to foriegn sites open in a new window/tab.
+        class NewPageLinksMDRenderer < Redcarpet::Render::HTML
+          # review's the link and renders the Html
+          def link(link, title, content)
+            "<a href=\"#{link}\"#{" target='_blank'" if link =~ /^http[s]?\:\/\//}#{" title=\"#{title}\"" if title}>#{content}</a>"
+          end
+        end
+
+        # Extensions
+        MD_EXTENSIONS = { with_toc_data: true, strikethrough: true, autolink: true, fenced_code_blocks: true, no_intra_emphasis: true, tables: true, footnotes: true, underline: true, highlight: true }.freeze
+        # create a single gloabl renderer for all markdown files.
+        MD_RENDERER = Redcarpet::Markdown.new NewPageLinksMDRenderer.new(MD_EXTENSIONS.dup), MD_EXTENSIONS.dup
+
+        # create a single gloabl renderer for all markdown TOC.
+        MD_RENDERER_TOC = Redcarpet::Markdown.new Redcarpet::Render::HTML_TOC.new(MD_EXTENSIONS.dup), MD_EXTENSIONS.dup
+
+        extend ::Plezi::Base::HasStore
+
+        module_function
+
+        # renders the markdown file, if exists
+        def call(filename, _context)
+          return unless File.exist?(filename)
+          load_engine(filename)
+        end
+
+        if ENV['RACK_ENV'.freeze] == 'production'.freeze
+          # loads the rendered cache
+          def load_engine(filename)
+            engine = self[filename]
+            return engine if engine
+            data = IO.read filename
+            self[filename] = "<div class='toc'>#{::Plezi::Base::RenderMarkDown::MD_RENDERER_TOC.render(data)}</div>\n#{::Plezi::Base::RenderMarkDown::MD_RENDERER.render(data)}"
+          end
+        else
+          # loads the rendered cache
+          def load_engine(filename)
+            engine, tm = self[filename]
+            return engine if engine && tm == File.mtime(filename)
+            data = IO.read filename
+            (self[filename] = ["<div class='toc'>#{::Plezi::Base::RenderMarkDown::MD_RENDERER_TOC.render(data)}</div>\n#{::Plezi::Base::RenderMarkDown::MD_RENDERER.render(data)}", File.mtime(filename)])[0]
+          end
+        end
+      end
+    end
+  end
+
+  ::Plezi::Renderer.register :md, ::Plezi::Base::RenderMarkDown
+end

data/lib/plezi/render/render.rb

@@ -0,0 +1,49 @@
+require 'thread'
+
+module Plezi
+  module Renderer
+    @render_library = {}.dup
+
+    public
+
+    module_function
+
+    # Registers a rendering extention.
+    #
+    # Slim, Markdown, ERB and SASS are registered by default.
+    #
+    # extention:: a Symbol or String representing the extention of the file to be rendered. i.e. 'slim', 'md', 'erb', etc'
+    # handler :: a Proc or other object that answers to call(filename, context, &block) and returnes the rendered string.
+    #            The block accepted by the handler is for chaining rendered actions (allowing for `yield` within templates)
+    #            and the context is the object within which the rendering should be performed (if `binding` handling is
+    #            supported by the engine). `filename` might not point to an existing or valid file.
+    #
+    # If a block is passed to the `register_hook` method with no handler defined, it will act as the handler.
+    def register(extention, handler = nil, &block)
+      handler ||= block
+      raise 'Handler or block required.' unless handler
+      @render_library[extention.to_s] = handler
+      handler
+    end
+
+    # Removes a registered render extention
+    def remove(extention)
+      @render_library.delete extention.to_s
+    end
+
+    # Attempts to render the requested file (i.e. `'index.html'`) using all known rendering handlers.
+    def render(base_filename, context = (Object.new.instance_eval { binding }), &block)
+      ret = nil
+      @render_library.each { |ext, handler| ret = handler.call("#{base_filename}.#{ext}".freeze, context, &block); return ret if ret; }
+      ret
+    end
+    # Renderer.register :haml do |filename, context, &block|
+    #   next unless defined? ::Haml
+    #   (Plezi.cache_needs_update?(filename) ? Plezi.cache_data(filename, Haml::Engine.new(Plezi::Base::Helpers.try_utf8!(IO.binread(filename)))) : (Plezi.get_cached filename)).render(context.receiver, &block)
+    # end
+  end
+end
+
+require 'plezi/render/slim.rb'
+require 'plezi/render/markdown.rb'
+require 'plezi/render/erb.rb'

data/lib/plezi/render/sass.rb

@@ -0,0 +1,55 @@
+require 'thread'
+require 'plezi/render/has_cache'
+# Redcarpet might not be available, if so, allow the require to throw it's exception.
+unless defined?(::Sass)
+  begin
+    require('sass')
+  rescue Exception
+
+  end
+end
+
+if defined?(::Sass)
+
+  module Plezi
+    module Base
+      # This is a baker, not a renderer
+      module BakeSASS
+        extend HasCache
+
+        module_function
+
+        SASS_OPTIONS = { cache_store: Sass::CacheStores::Memory.new, style: (ENV['SASS_STYLE'] || ((ENV['ENV'] || ENV['RACK_ENV']) == 'production' ? :compressed : :nested)) }.dup
+
+        # Bakes the SASS for the requested target, if a SASS source file is found.
+        def call(target)
+          return self[target] if File.extname(target) == '.map'.freeze
+          review_cache("#{target}.scss", target) || review_cache("#{target}.sass", target)
+        end
+
+        def review_cache(filename, target)
+          return nil unless File.exist?(filename)
+          eng = self[filename]
+          return true unless eng.nil? || refresh_sass?(filename)
+          self[filename] = (eng = Sass::Engine.for_file(filename, SASS_OPTIONS)).dependencies
+          map_name = "#{target}.map".freeze
+          css, map = eng.render_with_sourcemap(File.basename(map_name))
+          self[filename.to_sym] = Time.now
+          IO.write map_name, map.to_json(css_uri: File.basename(target))
+          self[target] = css
+        end
+
+        def refresh_sass?(sass)
+          mt = self[sass.to_sym]
+          return true if mt < File.mtime(sass)
+          self[sass].each { |e| return true if File.exist?(e.options[:filename]) && (File.mtime(e.options[:filename]) > mt) }
+          false
+        end
+      end
+
+      ::Plezi::AssetBaker.register :css, ::Plezi::Base::BakeSASS
+      ::Plezi::AssetBaker.register :map, ::Plezi::Base::BakeSASS
+    end
+  end
+
+end

data/lib/plezi/render/slim.rb

@@ -0,0 +1,33 @@
+require 'plezi/render/has_cache' unless defined? ::Plezi::Base::HasStore
+module Plezi
+  module Base
+    module RenderSlim
+      extend ::Plezi::Base::HasStore
+
+      module_function
+
+      def call(filename, context, &block)
+        return unless defined? ::Slim
+        return unless File.exist?(filename)
+        engine = load_engine(filename)
+        engine.render(context.receiver, &block)
+      end
+      if ENV['RACK_ENV'.freeze] == 'production'.freeze
+        def load_engine(filename)
+          engine = self[filename]
+          return engine if engine
+          self[filename] = (Slim::Template.new { ::Plezi.try_utf8!(IO.binread(filename)) })
+        end
+      else
+        def load_engine(filename)
+          engine, tm = self[filename]
+          return engine if engine && (tm == File.mtime(filename))
+          self[filename] = [(engine = Slim::Template.new { ::Plezi.try_utf8!(IO.binread(filename)) }), File.mtime(filename)]
+          engine
+        end
+      end
+    end
+  end
+end
+
+::Plezi::Renderer.register :slim, ::Plezi::Base::RenderSlim

data/lib/plezi/router/adclient.rb

@@ -0,0 +1,23 @@
+require 'plezi/router/route'
+require 'plezi/router/errors'
+require 'plezi/router/assets'
+require 'rack'
+
+module Plezi
+  module Base
+    module Router
+      class ADClient
+        def index
+          fname = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'resources', 'client.js'))
+          response.body = File.open(fname)
+          response['X-Sendfile'] = fname
+          true
+        end
+
+        def show
+          index
+        end
+      end
+    end
+  end
+end

data/lib/plezi/router/assets.rb

@@ -0,0 +1,67 @@
+require 'fileutils'
+require 'set'
+module Plezi
+  module Base
+    class Assets
+      if ENV['RACK_ENV'.freeze] == 'production'.freeze
+        def index
+          name = File.join(Plezi.assets, *params['*'.freeze]).freeze
+          data = ::Plezi::AssetBaker.bake(name)
+          return false unless data
+          name = File.join(Iodine::Rack.public, request.path_info[1..-1]).freeze if Iodine::Rack.public
+          if data.is_a?(String)
+            FileUtils.mkpath File.dirname(name)
+            IO.binwrite(name, data)
+          end
+          response['X-Sendfile'.freeze] = name
+          response.body = File.open(name)
+          true
+        end
+      else
+        def index
+          name = File.join(Plezi.assets, *params['*'.freeze]).freeze
+          data = ::Plezi::AssetBaker.bake(name)
+          IO.binwrite(name, data) if data.is_a?(String)
+          if File.exist? name
+            response['X-Sendfile'.freeze] = name
+            response.body = File.open(name)
+            return true
+          end
+          false
+        end
+      end
+
+      def show
+        index
+      end
+    end
+  end
+  # This module is used for asset "baking" (or "belated baking"). It allows us to easily register and support new types of assets.
+  module AssetBaker
+    @drivers = {}
+    # Registers a new Asset Driver of a specific extension (i.e. "css", "js", etc')
+    #
+    # Multiple Asset Drivers can be registered for the same extension. The will be attempted in the order of their registration.
+    #
+    # An Asset Drivers is an object that responsd to `.call(target)`.
+    # If the traget is newly rendered, the driver should return the rendered text.
+    # If the asset didn't change since the last time `.call(target)` was called, the driver should return 'true' (meanning, yet, the asset exists, it's the same).
+    # If the driver doesn't locate the asset, it should return `nil` or `false`, indicating the next driver should be attempted.
+    def self.register(ext, driver)
+      (@drivers[".#{ext}".freeze] ||= [].to_set) << driver
+    end
+
+    # @private
+    # called by Plezi when in need of baking an asset.
+    def self.bake(name)
+      ret = nil
+      ext = File.extname name
+      return false if ext.empty?
+      driver = @drivers[ext]
+      return false if driver.nil?
+      driver.each { |d| ret = d.call(name); return ret if ret }
+      nil
+    end
+  end
+end
+require 'plezi/render/sass.rb'