rack-webprofiler 0.1.0.pre.beta2 → 0.1.0

data/lib/rack/web_profiler/rouge/html_formatter.rb

@@ -0,0 +1,25 @@
+module Rack
+  #
+  class WebProfiler::Rouge::HTMLFormatter < ::Rouge::Formatter
+
+    # Initialize the Formatter.
+    #
+    # @param request [Hash]
+    def initialize(opts = {})
+      @formatter = opts[:inline_theme] \
+        ? ::Rouge::Formatters::HTMLInline.new(opts[:inline_theme])
+        : ::Rouge::Formatters::HTML.new
+
+      if opts[:line_numbers]
+        @formatter = ::Rouge::Formatters::HTMLTable.new(@formatter, opts)
+      else
+        @formatter = ::Rouge::Formatters::HTMLPygments.new(@formatter)
+      end
+    end
+
+    # @yield the html output.
+    def stream(tokens, &b)
+      @formatter.stream(tokens, &b)
+    end
+  end
+end

data/lib/rack/web_profiler/router.rb

@@ -28,6 +28,7 @@ module Rack
       # Route the request.
       #
       # @param request [Rack::WebProfiler::Request]
+      # @param path [String]
       #
       # @return [Rack::Reponse, false]
       def route(request, path)
@@ -58,8 +59,6 @@ module Rack
         request = @request.dup
         request.env[PATH_INFO] = "/#{path}"
 
-        path_info = Utils.unescape(request.env[PATH_INFO])
-        clean_path_info = Utils.clean_path_info(path_info)
 
         status, headers, body = rf.call(request.env)
         Rack::Response.new(body, status, headers)
@@ -71,7 +70,7 @@ module Rack
       #
       # @return [String]
       def url_for_asset(path)
-        "#{@request.script_name}#{BASE_PATH}/assets/#{path}"
+        "#{get_base_path}/assets/#{path}"
       end
 
       # Get url for toobar.
@@ -80,7 +79,7 @@ module Rack
       #
       # @return [String]
       def url_for_toolbar(token)
-        "#{@request.script_name}#{BASE_PATH}/toolbar/#{token}"
+        "#{get_base_path}/toolbar/#{token}"
       end
 
       # Get url for the webprofiler.
@@ -92,14 +91,20 @@ module Rack
       def url_for_profiler(token = nil, panel = nil)
         query = ""
         query = "?panel=#{panel}" unless panel.nil?
-        "#{@request.script_name}#{BASE_PATH}/#{token}#{query}"
+        "#{get_base_path}/#{token}#{query}"
       end
 
       # Get url to clean webprofiler.
       #
       # @return [String]
       def url_for_clean_profiler
-        "#{@request.script_name}#{BASE_PATH}/clean"
+        "#{get_base_path}/clean"
+      end
+
+      private
+
+      def get_base_path
+        "#{@request.env["ORIGINAL_SCRIPT_NAME"]}#{BASE_PATH}"
       end
     end
   end

data/lib/rack/web_profiler/version.rb

@@ -1,5 +1,5 @@
 module Rack
   class WebProfiler
-    VERSION = "0.1.0-beta2".freeze
+    VERSION = "0.1.0".freeze
   end
 end

data/lib/rack/web_profiler/view.rb

@@ -5,29 +5,53 @@ module Rack
   class WebProfiler
     # View
     class View
+      # Initialize a new view.
+      #
+      # @param template [String] template file path or content
+      # @option layout [String, nil] layout file path or content
+      # @option context [Rack::WebProfiler::View::Context, nil]
       def initialize(template, layout: nil, context: nil)
         @template  = template
         @layout    = layout
         @context   = context
+
+        @erb_options = {
+          safe_level: nil,
+          trim_mode:  "<>-",
+          eoutvar:    "@_erbout",
+        }
       end
 
+      # Get the result of view rendering.
+      #
+      # @param variables [Hash, Binding] view variables
+      #
+      # @return [String]
       def result(variables = {})
         unless @template.nil?
           templates = [read_template(@template)]
           templates << read_template(@layout) unless @layout.nil?
 
-          content = templates.inject(nil) do |prev, temp|
+          templates.inject(nil) do |prev, temp|
             render(temp, variables) { prev }
           end
         end
       end
 
+      # Get the context.
+      #
+      # @return [Rack::WebProfiler::View::Context]
       def context
         @context ||= Context.new
       end
 
-      private
+      protected
 
+      # Read a template. Returns file content if template is a file path.
+      #
+      # @param template [String] template file path or content
+      #
+      # @return [String]
       def read_template(template)
         unless template.empty?
           path = ::File.expand_path("../../templates/#{template}", __FILE__)
@@ -36,36 +60,35 @@ module Rack
         template
       end
 
-      def options
-        @options ||= {
-          :safe_level => nil,
-          :trim_mode  => '%-',
-          :eoutvar    => '@_erbout',
-        }
-      end
-
+      # Render view.
+      #
+      # @param str [String] view content
+      # @param variables [Hash, Binding] view variables
+      #
+      # @return [String]
+      #
+      # @todo better error when there is an ERB error.
       def render(str, variables = {})
-        opts = options
-
         format_variables(variables).each do |name, value|
           context.instance_variable_set("@#{name}", value)
         end
 
+        erb = ::ERB.new(str, *@erb_options.values_at(:safe_level, :trim_mode, :eoutvar))
+
         context.instance_eval do
-          erb = ::ERB.new(str, *opts.values_at(:safe_level, :trim_mode, :eoutvar))
-          erb.result(binding).sub(/\A\n/, '')
+          erb.result(binding).sub(/\A\n/, "")
         end
-        # @todo better error when there is an ERB error.
       end
 
+      # Format variables to inject them into view context.
+      #
+      # @param v [Hash, Binding] variables
+      #
+      # @return [Hash]
       def format_variables(v)
         case v
         when Binding
-          h = {}
-          v.eval("instance_variables").each do |k|
-            h[k.to_s.sub(/^@/, '')] = v.eval("instance_variable_get(:#{k})")
-          end
-          h
+          binding_to_hash(v)
         when Hash
           v
         else
@@ -73,163 +96,256 @@ module Rack
         end
       end
 
-      # CommonHelpers.
-      module CommonHelpers
-        def content_for(key, content = nil, &block)
-          block ||= proc { |*| content }
-          content_blocks[key.to_sym] << capture_later(&block)
-        end
-
-        def content_for?(key)
-          content_blocks[key.to_sym].any?
+      # Returns a [Hash] from a [Binding].
+      #
+      # @param v [Binding]
+      #
+      # @return [Hash]
+      def binding_to_hash(v)
+        h = {}
+        v.eval("instance_variables").each do |k|
+          h[k.to_s.sub(/^@/, "")] = v.eval("instance_variable_get(:#{k})")
         end
+        h
+      end
 
-        def yield_content(key, default = nil)
-          return default if content_blocks[key.to_sym].empty?
-          content_blocks[key.to_sym].map { |b| capture(&b) }.join
-        end
-
-        #
-        def partial(path, variables: nil)
-          return "" if path.nil?
-
-          variables ||= binding if variables.nil?
-
-          capture do
-            WebProfiler::View.new(path, context: self).result(variables)
+      # Helpers.
+      module Helpers
+        # Common helpers.
+        module Common
+          def content_for(key, content = nil, &block)
+            block ||= proc { |*| content }
+            content_blocks[key.to_sym] << capture_later(&block)
           end
-        end
 
-        #
-        def h(obj)
-          case obj
-          when String
-            ::ERB::Util.html_escape(obj)
-          else
-            ::ERB::Util.html_escape(obj.inspect)
+          def content_for?(key)
+            content_blocks[key.to_sym].any?
           end
-        end
 
-        #
-        def highlight(code: nil, language: nil)
-          language = language.to_sym if language.is_a? String
-
-          case language
-          when :ruby
-            lexer = Rouge::Lexers::Ruby.new
-          when :json
-            lexer = Rouge::Lexers::Jsonnet.new
-          when :xml
-            lexer = Rouge::Lexers::XML.new
-          else
-            lexer = Rouge::Lexers::PlainText.new
+          def yield_content(key, default = nil)
+            return default if content_blocks[key.to_sym].empty?
+            content_blocks[key.to_sym].map { |b| capture(&b) }.join
           end
 
-          code = capture(&Proc.new) if block_given?
+          # Render a partial view.
+          #
+          # @param path [String] path to partial
+          # @option variables [Hash, nil] variables for partial
+          #
+          # @return [String]
+          def partial(path, variables: nil)
+            return "" if path.nil?
 
-          formatter = Rouge::Formatters::HTML.new
-          formatter = Rouge::Formatters::HTMLPygments.new(formatter, css_class='highlight')
+            variables ||= binding if variables.nil?
 
-          "<div class=\"highlight\">#{formatter.format(lexer.lex(code))}</div>"
-        end
+            capture do
+              WebProfiler::View.new(path, context: self).result(variables)
+            end
+          end
 
-        def capture(&block)
-          @capture = nil
-          @_erbout, _buf_was = '', @_erbout
-          result = yield
-          @_erbout = _buf_was
-          result.strip.empty? && @capture ? @capture : result
-        end
+          # Escape html.
+          #
+          # @param obj
+          #
+          # @return [String]
+          def h(obj)
+            case obj
+            when String
+              ::ERB::Util.html_escape(obj)
+            else
+              ::ERB::Util.html_escape(obj.inspect)
+            end
+          end
 
-        private
+          # Highlight text.
+          #
+          # @option code [String]
+          # @option mimetype [String, nil]
+          # @option language [String, nil]
+          # @option formatter_opts [Hash]
+          #
+          # @yield code.
+          #
+          # @return [String]
+          def highlight(code: "", mimetype: nil, language: nil, formatter_opts: {})
+            language = language.to_s if language.is_a? Symbol
+
+            lexer = ::Rouge::Lexer.guess(mimetype: mimetype) if mimetype.is_a? String
+            lexer = ::Rouge::Lexer.find_fancy(language)      if language.is_a? String
+            lexer ||= ::Rouge::Lexers::PlainText.new
+
+            code = capture(&Proc.new) if block_given?
+            code ||= ""
+
+            formatter = WebProfiler::Rouge::HTMLFormatter.new(formatter_opts)
+
+            "<div class=\"highlight\">#{formatter.format(lexer.lex(code))}</div>"
+          end
 
-        def capture_later(&block)
-          proc { |*| @capture = capture(&block) }
-        end
+          #
+          #
+          # @yield
+          def capture(&block)
+            @capture = nil
+            buf_was  =  @_erbout
+            @_erbout = ""
 
-        def content_blocks
-          @content_blocks ||= Hash.new {|h,k| h[k] = [] }
-        end
-      end
+            result = yield
 
-      # CollectorHelpers.
-      module CollectorHelpers
+            @_erbout = buf_was
+            result.strip.empty? && @capture ? @capture : result
+          end
 
-        #
-        def collector_status(collector, collection)
-          collector_data_storage(collector, collection, :status)
-        end
+          #
+          #
+          # @yield
+          def capture_later(&block)
+            proc { |*| @capture = capture(&block) }
+          end
+
+          private
 
-        #
-        def collector_datas(collector, collection)
-          collector_data_storage(collector, collection, :datas)
+          #
+          #
+          # @return [Hash]
+          def content_blocks
+            @content_blocks ||= Hash.new { |h, k| h[k] = [] }
+          end
         end
 
-        def collector_tab(collector, collection)
-          return nil unless is_collection_contains_datas_for_collector?(collection, collector)
+        # Collector helpers.
+        module Collector
+          # Get collector status from a collection.
+          #
+          # @param collector [Rack::WebProfiler::Collector::Definition]
+          # @param collection [Rack::WebProfiler::Model::CollectionRecord]
+          #
+          # @return [Symbol, nil]
+          def collector_status(collector, collection)
+            collector_data_storage(collector, collection, :status)
+          end
 
-          c = collector_view_context(collector, collection)
-          c.tab_content
-        end
+          #
+          #
+          # @param collector [Rack::WebProfiler::Collector::Definition]
+          # @param collection [Rack::WebProfiler::Model::CollectionRecord]
+          def collector_datas(collector, collection)
+            collector_data_storage(collector, collection, :datas)
+          end
 
-        def collector_panel(collector, collection)
-          return nil unless is_collection_contains_datas_for_collector?(collection, collector)
+          #
+          # @param collector [Rack::WebProfiler::Collector::Definition]
+          # @param collection [Rack::WebProfiler::Model::CollectionRecord]
+          def collector_tab(collector, collection)
+            return nil unless collection_contains_datas_for_collector?(collection, collector)
 
-          c = collector_view_context(collector, collection)
-          c.panel_content
-        end
+            c = collector_view_context(collector, collection)
+            c.tab_content
+          end
 
-        def collector_has_tab?(collector, collection)
-          collector_data_storage(collector, collection, :show_tab)
-        end
+          #
+          # @param collector [Rack::WebProfiler::Collector::Definition]
+          # @param collection [Rack::WebProfiler::Model::CollectionRecord]
+          def collector_panel(collector, collection)
+            return nil unless collection_contains_datas_for_collector?(collection, collector)
 
-        def collector_has_panel?(collector, collection)
-          collector_data_storage(collector, collection, :show_panel)
-        end
+            c = collector_view_context(collector, collection)
+            c.panel_content
+          end
 
-        private
+          #
+          # @param collector [Rack::WebProfiler::Collector::Definition]
+          # @param collection [Rack::WebProfiler::Model::CollectionRecord]
+          def collector_has_tab?(collector, collection)
+            collector_data_storage(collector, collection, :show_tab)
+            # !collector_tab(collector, collection).nil?
+          end
 
-        def collector_view_context(collector, collection)
-          collectors_view_context[collector.name] ||= begin
-            v = WebProfiler::Collector::View.new(collector.template)
-            v.result(collector: collector, collection: collection)
-            v.context
+          #
+          # @param collector [Rack::WebProfiler::Collector::Definition]
+          # @param collection [Rack::WebProfiler::Model::CollectionRecord]
+          def collector_has_panel?(collector, collection)
+            collector_data_storage(collector, collection, :show_panel)
+            # !collector_panel(collector, collection).nil?
           end
-        end
 
-        def collector_data_storage(collector, collection, key = nil)
-          return nil unless is_collection_contains_datas_for_collector?(collection, collector)
+          private
+
+          # Get a collector view Context.
+          #
+          # @param collector [Rack::WebProfiler::Collector::Definition]
+          # @param collection [Rack::WebProfiler::Model::CollectionRecord]
+          #
+          # @return [Rack::WebProfiler::View::Context]
+          def collector_view_context(collector, collection)
+            collectors_view_context[collector.identifier] ||= begin
+              v = WebProfiler::Collector::View.new(collector.template)
+              v.result(collector: collector, collection: collection)
+              v.context
+            end
+          end
 
-          storage = collection.datas[collector.name.to_sym]
-          storage[key] if !key.nil? && storage.has_key?(key)
-        end
+          #
+          #
+          # @param collector [Rack::WebProfiler::Collector::Definition]
+          # @param collection [Rack::WebProfiler::Model::CollectionRecord]
+          # @param key [Symbol, String]
+          #
+          # @return
+          def collector_data_storage(collector, collection, key = nil)
+            return nil unless collection_contains_datas_for_collector?(collection, collector)
+
+            storage = collection.datas[collector.identifier.to_sym]
+            storage[key] if !key.nil? && storage.key?(key)
+          end
 
-        def is_valid_collector?(collector)
-          !collector.nil? \
-            && collector.kind_of?(WebProfiler::Collector::Definition)
-        end
+          # Check if collector is valid.
+          #
+          # @param collector [Rack::WebProfiler::Collector::Definition]
+          #
+          # @return [Boolean]
+          def valid_collector?(collector)
+            !collector.nil? \
+              && collector.is_a?(WebProfiler::Collector::Definition)
+          end
 
-        def is_valid_collection?(collection)
-          !collection.nil? \
-            && collection.kind_of?(WebProfiler::Model::CollectionRecord)
-        end
+          # Check if collection is valid.
+          #
+          # @param collection [Rack::WebProfiler::Model::CollectionRecord]
+          #
+          # @return [Boolean]
+          def valid_collection?(collection)
+            !collection.nil? \
+              && collection.is_a?(WebProfiler::Model::CollectionRecord)
+          end
 
-        def is_collection_contains_datas_for_collector?(collection, collector)
-          is_valid_collector?(collector) \
-            && is_valid_collection?(collection) \
-            && collection.datas.has_key?(collector.name.to_sym)
-        end
+          # @param collector [Rack::WebProfiler::Collector::Definition]
+          # @param collection [Rack::WebProfiler::Model::CollectionRecord]
+          #
+          # @return [Boolean]
+          def collection_contains_datas_for_collector?(collection, collector)
+            valid_collector?(collector) \
+              && valid_collection?(collection) \
+              && collection.datas.key?(collector.identifier.to_sym)
+          end
 
-        private
+          private
 
-        def collectors_view_context
-          @collectors_view_context ||= {}
+          # Get the collectors view context.
+          #
+          # @return [Hash]
+          def collectors_view_context
+            @collectors_view_context ||= {}
+          end
         end
       end
 
+      # View Context.
       class Context
-        include CommonHelpers
-        include CollectorHelpers
+
+        # Include helpers into the Context.
+        include Helpers::Common
+        include Helpers::Collector
       end
     end
   end

data/lib/rack/web_profiler.rb

@@ -10,29 +10,69 @@ module Rack
     autoload :Controller, "rack/web_profiler/controller"
     autoload :Engine,     "rack/web_profiler/engine"
     autoload :Model,      "rack/web_profiler/model"
+    autoload :Response,   "rack/web_profiler/response"
     autoload :Request,    "rack/web_profiler/request"
     autoload :Router,     "rack/web_profiler/router"
     autoload :View,       "rack/web_profiler/view"
 
+    # Classes about Rouge gem customization.
+    module Rouge
+      autoload :HTMLFormatter, "rack/web_profiler/rouge/html_formatter"
+    end
+
+    # Env key constants.
+    ENV_RUNTIME_START = "rack_webprofiler.runtime_start".freeze
+    ENV_RUNTIME       = "rack_webprofiler.runtime".freeze
+    ENV_EXCEPTION     = "rack_webprofiler.exception".freeze
+
     class << self
+      # Configure the WebProfiler.
+      #
+      # @yield the Config object.
+      #
+      # @return [Rack::WebProfiler::Config]
       def config
         @config ||= Config.new
         @config.build!(&Proc.new) if block_given?
         @config
       end
 
+      # Register one or many collectors.
+      #
+      # @param collector_class [Array, Class]
       def register_collector(collector_class)
         config.collectors.add_collector collector_class
       end
+      alias register_collectors register_collector
 
+      # Unregister one or many collectors.
+      #
+      # @param collector_class [Array, Class]
       def unregister_collector(collector_class)
         config.collectors.remove_collector collector_class
       end
+      alias unregister_collectors unregister_collector
+
+      def data(k = nil, v = :undefined)
+        @data ||= {}
+
+        return @data if k === nil
+
+        @data[k] = v unless v === :undefined
+        @data[k] if @data.key?(k)
+      end
+
+      def reset_data!
+        @data = {}
+      end
     end
 
+    attr_reader :data
+
     # Initialize
     #
     # @param app [Proc]
+    # @option tmp_dir [String]
     def initialize(app, tmp_dir: nil)
       @app = app
 
@@ -46,9 +86,11 @@ module Rack
     #
     # @return [Array]
     def call(env)
+      WebProfiler.reset_data!
+
       begin
         request = WebProfiler::Request.new(env)
-        request.start_runtime!
+        env[ENV_RUNTIME_START] = Time.now.to_f
 
         response = WebProfiler::Router.response_for(request)
         return response.finish if response.is_a? Rack::Response
@@ -74,10 +116,11 @@ module Rack
     #
     # @return [Rack::Response]
     def process(request, body, status, headers, exception = nil)
-      request.save_runtime!
+      request.env[ENV_RUNTIME]   = Time.now.to_f - request.env[ENV_RUNTIME_START]
+      request.env[ENV_EXCEPTION] = nil
 
-      unless exception.nil?
-        request.save_exception(exception)
+      if !exception.nil?
+        request.env[ENV_EXCEPTION] = exception
         WebProfiler::Engine.process_exception(request).finish
       else
         WebProfiler::Engine.process(request, body, status, headers).finish