plezi 0.14.4 → 0.14.5

data/lib/plezi/helpers.rb

@@ -2,13 +2,13 @@ require 'plezi/activation'
 require 'plezi/router/router'
 
 module Plezi
-  module_function
+   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
+     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:
@@ -21,40 +21,40 @@ module Plezi
   #
   # 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
+     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
+     @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/render/erb.rb

@@ -1,34 +1,33 @@
 require 'plezi/render/has_cache' unless defined? ::Plezi::Base::HasStore
-require 'erb'
 module Plezi
-  module Base
-    module RenderERB
-      extend ::Plezi::Base::HasStore
+   module Base
+      module RenderERB
+         extend ::Plezi::Base::HasStore
 
-      module_function
+         module_function
 
-      def call(filename, context, &block)
-        return unless defined? ::ERB
-        return unless File.exist?(filename)
-        engine = load_engine(filename)
-        engine.result(context, &block)
+         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
-      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
 end
 
 ::Plezi::Renderer.register :erb, ::Plezi::Base::RenderERB

data/lib/plezi/render/has_cache.rb

@@ -1,36 +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
+   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
+         # 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
-      alias []= store
-      # Retrieves data form the cache
-      def get(key)
-        (Thread.current[(@_chache_name ||= object_id.to_s(16))] ||= {}.dup)[key]
+      # 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
-      alias [] get
-    end
-  end
+   end
 end

data/lib/plezi/render/markdown.rb

@@ -1,63 +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
+   begin
+      require('redcarpet')
+   rescue Exception
 
-  end
+   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
+   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
-  end
+   end
 
-  ::Plezi::Renderer.register :md, ::Plezi::Base::RenderMarkDown
+   ::Plezi::Renderer.register :md, ::Plezi::Base::RenderMarkDown
 end

data/lib/plezi/render/render.rb

@@ -1,47 +1,45 @@
-require 'thread'
-
 module Plezi
-  module Renderer
-    @render_library = {}.dup
+   module Renderer
+      @render_library = {}.dup
 
-    public
+      public
 
-    module_function
+      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
+      # 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
+      # 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
+      # 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'

data/lib/plezi/render/sass.rb

@@ -1,55 +1,54 @@
-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
+   begin
+      require('sass')
+   rescue Exception
 
-  end
+   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
+   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
-
-      ::Plezi::AssetBaker.register :css, ::Plezi::Base::BakeSASS
-      ::Plezi::AssetBaker.register :map, ::Plezi::Base::BakeSASS
-    end
-  end
+   end
 
 end