plezi 0.14.4 → 0.14.5

data/lib/plezi/render/slim.rb

@@ -1,33 +1,33 @@
 require 'plezi/render/has_cache' unless defined? ::Plezi::Base::HasStore
 module Plezi
-  module Base
-    module RenderSlim
-      extend ::Plezi::Base::HasStore
+   module Base
+      module RenderSlim
+         extend ::Plezi::Base::HasStore
 
-      module_function
+         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)
+         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
-      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
 end
 
 ::Plezi::Renderer.register :slim, ::Plezi::Base::RenderSlim

data/lib/plezi/router/adclient.rb

@@ -1,23 +1,22 @@
 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
+   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
+            def show
+               index
+            end
+         end
       end
-    end
-  end
+   end
 end

data/lib/plezi/router/assets.rb

@@ -1,67 +1,65 @@
-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
+   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
+         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
-    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
+      # @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'

data/lib/plezi/router/errors.rb

@@ -1,29 +1,29 @@
 module Plezi
-  module Base
-    class Err404Ctrl
-      def index
-        response.status = 404
-        render('404') || 'Error 404, not found.'
-      end
+   module Base
+      class Err404Ctrl
+         def index
+            response.status = 404
+            render('404') || 'Error 404, not found.'
+         end
 
-      def requested_method
-        :index
-      end
+         def requested_method
+            :index
+         end
 
-      include Plezi::Controller
-    end
-    class Err500Ctrl
-      def index
-        response.status = 500
-        render('500') || 'Internal Error 500.'
-      rescue
-        'Internal Error 500.'
+         include Plezi::Controller
       end
+      class Err500Ctrl
+         def index
+            response.status = 500
+            render('500') || 'Internal Error 500.'
+         rescue
+            'Internal Error 500.'
+         end
 
-      def requested_method
-        :index
+         def requested_method
+            :index
+         end
+         include Plezi::Controller
       end
-      include Plezi::Controller
-    end
-  end
+   end
 end

data/lib/plezi/router/route.rb

@@ -1,113 +1,111 @@
 require 'plezi/controller/controller'
-require 'thread'
-require 'rack'
-require 'rack/query_parser.rb'
 
 module Plezi
-  module Base
-    class Route
-      attr_reader :prefix, :controller, :param_names
+   module Base
+      class Route
+         attr_reader :prefix, :controller, :param_names
 
-      def initialize(path, controller)
-        @route_id = "Route#{object_id.to_s(16)}".to_sym
-        m = path.match(/([^\:\(\*]*)(.*)/)
-        @prefix = m[1].chomp('/'.freeze)
-        if @prefix.nil? || @prefix == ''.freeze
-          @prefix = '/'.freeze
-          @prefix_length = 1
-        else
-          @prefix = "/#{@prefix}" if @prefix[0] != '/'.freeze
-          @prefix_length = @prefix.length + 1
-        end
-        @controller = controller
-        @param_names = []
-        @origial = path.dup.freeze
-        prep_params(m[2])
-        self.class.qp
-        case @controller
-        when Class
-          prep_controller
-        when Regexp
-          raise "Rewrite Routes can't contain more then one parameter to collect" if @param_names.length > 1
-        else
-          raise 'Controller should be a class object' unless controller.is_a?(Class)
-        end
-      end
+         def initialize(path, controller)
+            @route_id = "Route#{object_id.to_s(16)}".to_sym
+            @params_range = (0..0)
+            m = path.match(/([^\:\(\*]*)(.*)/)
+            @prefix = m[1].chomp('/'.freeze)
+            if @prefix.nil? || @prefix == ''.freeze
+               @prefix = '/'.freeze
+               @prefix_length = 1
+            else
+               @prefix = "/#{@prefix}" if @prefix[0] != '/'.freeze
+               @prefix_length = @prefix.length + 1
+            end
+            @controller = controller
+            @param_names = []
+            @origial = path.dup.freeze
+            prep_params(m[2])
+            self.class.qp
+            case @controller
+            when Class
+               prep_controller
+            when Regexp
+               raise "Rewrite Routes can't contain more then one parameter to collect" if @param_names.length > 1
+            else
+               raise 'Controller should be a class object' unless controller.is_a?(Class)
+            end
+         end
 
-      def call(request, response)
-        return nil unless match(request.path_info, request)
-        c = @controller.new
-        c._pl_respond(request, response, Thread.current[@route_id])
-      end
+         def call(request, response)
+            return nil unless match(request.path_info, request)
+            c = @controller.new
+            c._pl_respond(request, response, Thread.current[@route_id])
+         end
 
-      def fits_params(path, request)
-        params = (Thread.current[@route_id] ||= {}).clear
-        params.update request.params.to_h if request && request.params
-        # puts "cutting: #{path[(@prefix_length)..-1] ? path[(@prefix_length + 1)..-1] : 'nil'}"
-        pa = (path[@prefix_length..-1] || ''.freeze).split('/'.freeze)
-        # puts "check param count: #{pa}"
-        return false unless @params_range.include?(pa.length)
-        @param_names.each do |key|
-          next if pa[0].nil?
-          self.class.qp.normalize_params(params, Plezi.try_utf8!(Rack::Utils.unescape(key)),
-                                         Plezi.try_utf8!(Rack::Utils.unescape(pa.shift)), 100)
-        end
-        params['*'.freeze] = pa unless pa.empty?
-        true
-      end
+         def fits_params(path, request)
+            params = (Thread.current[@route_id] ||= {}).clear
+            params.update request.params.to_h if request && request.params
+            # puts "cutting: #{path[(@prefix_length)..-1] ? path[(@prefix_length + 1)..-1] : 'nil'}"
+            pa = (path[@prefix_length..-1] || ''.freeze).split('/'.freeze)
+            # puts "check param count: #{pa}"
+            return false unless @params_range.include?(pa.length)
+            @param_names.each do |key|
+               next if pa[0].nil?
+               self.class.qp.normalize_params(params, Plezi.try_utf8!(Rack::Utils.unescape(key)),
+                                              Plezi.try_utf8!(Rack::Utils.unescape(pa.shift)), 100)
+            end
+            params['*'.freeze] = pa unless pa.empty?
+            true
+         end
 
-      def match(req_path, request = nil)
-        # puts "#{req_path} starts with #{@prefix}? #{req_path.start_with?(@prefix)}"
-        req_path.start_with?(@prefix) && fits_params(req_path, request)
-      end
+         def match(req_path, request = nil)
+            # puts "#{req_path} starts with #{@prefix}? #{req_path.start_with?(@prefix)}"
+            req_path.start_with?(@prefix) && fits_params(req_path, request)
+         end
 
-      def prep_params(postfix)
-        pfa = postfix.split '/'.freeze
-        start = 0; stop = 0
-        optional = false
-        while pfa.any?
-          name = pfa.shift
-          raise "#{name} is not a valid path section in #{@origial}" if /^((\:[\w\.\[\]]+)|(\(\:[\w\.\[\]]+\))|(\*))$/.match(name).nil?
-          if name[0] == ':'
-            raise "Cannot have a required parameter after an optional parameter in #{@origial}" if optional
-            @param_names << name[1..-1].freeze
-          elsif name[0] == '('
-            optional = true
-            @param_names << name[2..-2].freeze
-          elsif name[0] == '*'
-            stop += 999_999
-            break
-          else
-            raise "invalid path section #{name} in #{@origial}"
-          end
-          optional ? (stop += 1) : (start += 1)
-        end
-        unless (@param_names.include? 'id'.freeze) || stop >= 999_999
-          @param_names << 'id'.freeze
-          stop += 1
-        end
-        @params_range = (start..(start + stop))
-        @param_names.freeze
-        @params_range.freeze
-      end
+         def prep_params(postfix)
+            pfa = postfix.split '/'.freeze
+            start = 0; stop = 0
+            optional = false
+            while pfa.any?
+               name = pfa.shift
+               raise "#{name} is not a valid path section in #{@origial}" unless /^((\:[\w\.\[\]]+)|(\(\:[\w\.\[\]]+\))|(\*))$/.match(name)
+               if name[0] == ':'
+                  raise "Cannot have a required parameter after an optional parameter in #{@origial}" if optional
+                  @param_names << name[1..-1].freeze
+               elsif name[0] == '('
+                  optional = true
+                  @param_names << name[2..-2].freeze
+               elsif name[0] == '*'
+                  stop += 999_999
+                  break
+               else
+                  raise "invalid path section #{name} in #{@origial}"
+               end
+               optional ? (stop += 1) : (start += 1)
+            end
+            unless (@param_names.include? 'id'.freeze) || stop >= 999_999
+               @param_names << 'id'.freeze
+               stop += 1
+            end
+            @params_range = (start..(start + stop))
+            @param_names.freeze
+            @params_range.freeze
+         end
 
-      def prep_controller
-        @controller.include Plezi::Controller
-      end
+         def prep_controller
+            @controller.include Plezi::Controller
+         end
 
-      def self.qp
-        @qp ||= ::Rack::QueryParser.new(Hash, 65_536, 100)
+         def self.qp
+            @qp ||= ::Rack::QueryParser.new(Hash, 65_536, 100)
+         end
       end
-    end
-    class RouteRewrite < Route
-      def call(request, _response)
-        return nil unless match(request.path_info, request)
-        params = Thread.current[@route_id]
-        return nil unless controller =~ params[@param_names[0]]
-        request.path_info = "/#{params.delete('*'.freeze).to_a.join '/'}"
-        request.params.update params
-        nil
+      class RouteRewrite < Route
+         def call(request, _response)
+            return nil unless match(request.path_info, request)
+            params = Thread.current[@route_id]
+            return nil unless controller =~ params[@param_names[0]]
+            request.path_info = "/#{params.delete('*'.freeze).to_a.join '/'}"
+            request.params.update params
+            nil
+         end
       end
-    end
-  end
+   end
 end