request-log-analyzer 1.13.1 → 1.13.3

data/lib/request_log_analyzer/file_format/postgresql.rb

@@ -1,20 +1,18 @@
 module RequestLogAnalyzer::FileFormat
-
   # PostgresQL spec 8.3.7
   class Postgresql < Base
-
     extend CommonRegularExpressions
-    
+
     line_definition :query do |line|
       line.header = true
       line.teaser = /.*LOG\:/
       line.regexp = /(#{timestamp('%Y-%m-%d %k:%M:%S')})\ \S+ \[\d+\]\:\ \[.*\]\ LOG\:\ \ \d+\:\ duration\: (.*)\ ms\ \ statement:\ (.*)/
 
       line.capture(:timestamp).as(:timestamp)
-      line.capture(:query_time).as(:duration, :unit => :sec)
+      line.capture(:query_time).as(:duration, unit: :sec)
       line.capture(:query_fragment)
     end
-      
+
     line_definition :location do |line|
       line.footer = true
       line.teaser = /.*LOCATION:/
@@ -22,7 +20,7 @@ module RequestLogAnalyzer::FileFormat
 
       line.capture(:query).as(:sql) # Hack to gather up fragments
     end
-    
+
     line_definition :query_fragment do |line|
       line.regexp = /^(?!.*LOG)\s*(.*)\s*/
       line.capture(:query_fragment)
@@ -30,14 +28,12 @@ module RequestLogAnalyzer::FileFormat
 
     report do |analyze|
       analyze.timespan
-      analyze.hourly_spread      
-      analyze.duration :query_time, :category => :query, :title => 'Query time'
+      analyze.hourly_spread
+      analyze.duration :query_time, category: :query, title: 'Query time'
     end
-  
-    class Request < RequestLogAnalyzer::Request
 
-      def convert_sql(value, definition)
-        
+    class Request < RequestLogAnalyzer::Request
+      def convert_sql(value, _definition)
         # Recreate the full SQL query by joining all the previous parts and this last line
         sql = every(:query_fragment).join("\n") + value
 
@@ -52,7 +48,7 @@ module RequestLogAnalyzer::FileFormat
         sql.gsub!(/(:int,)+:int/, ':ints')                                # replace multiple ints by a list
         sql.gsub!(/(:string,)+:string/, ':strings')                       # replace multiple strings by a list
 
-        return sql.lstrip.rstrip
+        sql.lstrip.rstrip
       end
 
       def host
@@ -60,9 +56,9 @@ module RequestLogAnalyzer::FileFormat
       end
 
       # Convert the timestamp to an integer
-      def convert_timestamp(value, definition)
+      def convert_timestamp(value, _definition)
         _, y, m, d, h, i, s = value.split(/(\d\d)-(\d\d)-(\d\d)\s+(\d?\d):(\d\d):(\d\d)/)
-        ('20%s%s%s%s%s%s' % [y,m,d,h.rjust(2, '0'),i,s]).to_i
+        ('20%s%s%s%s%s%s' % [y, m, d, h.rjust(2, '0'), i, s]).to_i
       end
     end
   end

data/lib/request_log_analyzer/file_format/rack.rb

@@ -1,7 +1,5 @@
 module RequestLogAnalyzer::FileFormat
-
   class Rack < Apache
-
     def self.create(*args)
       super(:rack, *args)
     end

data/lib/request_log_analyzer/file_format/rails.rb

@@ -1,79 +1,77 @@
 module RequestLogAnalyzer::FileFormat
-
   # Default FileFormat class for Rails logs.
   #
   # Instances will be created dynamically based on the lines you want it to parse. You can
   # specify what lines should be included in the parser by providing a list to the create
   # method as first argument.
   class Rails < Base
-
     extend CommonRegularExpressions
 
     # Creates a Rails FileFormat instance.
     #
-    # The lines that will be parsed can be defined by the argument to this function, 
+    # The lines that will be parsed can be defined by the argument to this function,
     # which should be an array of line names, or a list of line names as comma separated
-    # string. The resulting report depends on the lines that will be parsed. You can 
+    # string. The resulting report depends on the lines that will be parsed. You can
     # also provide s string that describes a common set of lines, like "production",
     # "development" or "production".
     def self.create(lines = 'production')
       definitions_hash = line_definer.line_definitions.clone
-      
-      lines = lines.to_s.split(',') if lines.kind_of?(String)
-      lines = [lines.to_s]          if lines.kind_of?(Symbol)
-      
+
+      lines = lines.to_s.split(',') if lines.is_a?(String)
+      lines = [lines.to_s]          if lines.is_a?(Symbol)
+
       lines.each do |line|
         line = line.to_sym
-        if LINE_COLLECTIONS.has_key?(line)
+        if LINE_COLLECTIONS.key?(line)
           LINE_COLLECTIONS[line].each { |l| definitions_hash[l] ||= LINE_DEFINITIONS[l] }
-        elsif LINE_DEFINITIONS.has_key?(line)
+        elsif LINE_DEFINITIONS.key?(line)
           definitions_hash[line] ||= LINE_DEFINITIONS[line]
         else
-          raise "Unrecognized Rails log line name: #{line.inspect}!"
+          fail "Unrecognized Rails log line name: #{line.inspect}!"
         end
       end
 
-      return self.new(definitions_hash, report_trackers(definitions_hash))
+      new(definitions_hash, report_trackers(definitions_hash))
     end
-    
+
     # Creates trackers based on the specified line definitions.
     #
     # The more lines that will be parsed, the more information will appear in the report.
     def self.report_trackers(lines)
       analyze = RequestLogAnalyzer::Aggregator::Summarizer::Definer.new
-      
+
       analyze.timespan
       analyze.hourly_spread
-      
-      analyze.frequency :category => REQUEST_CATEGORIZER, :title => 'Most requested'
-      analyze.frequency :method, :title => 'HTTP methods'
-      analyze.frequency :status, :title => 'HTTP statuses returned'
-      
-      if lines.has_key?(:cache_hit)
-        analyze.frequency(:category => lambda { |request| request =~ :cache_hit ? 'Cache hit' : 'No hit' }, 
-              :title => 'Rails action cache hits')
+
+      analyze.frequency category: REQUEST_CATEGORIZER, title: 'Most requested'
+      analyze.frequency :method, title: 'HTTP methods'
+      analyze.frequency :status, title: 'HTTP statuses returned'
+
+      if lines.key?(:cache_hit)
+        analyze.frequency(category: lambda { |request| request =~ :cache_hit ? 'Cache hit' : 'No hit' },
+                          title: 'Rails action cache hits')
       end
-      
-      analyze.duration :duration, :category => REQUEST_CATEGORIZER, :title => "Request duration",    :line_type => :completed
-      analyze.duration :view,     :category => REQUEST_CATEGORIZER, :title => "View rendering time", :line_type => :completed
-      analyze.duration :db,       :category => REQUEST_CATEGORIZER, :title => "Database time",       :line_type => :completed
-      
-      analyze.frequency :category => REQUEST_CATEGORIZER, :title => 'Process blockers (> 1 sec duration)',
-        :if => lambda { |request| request[:duration] && request[:duration] > 1.0 }
-      
-      if lines.has_key?(:failure)
-        analyze.frequency :error, :title => 'Failed requests', :line_type => :failure
+
+      analyze.duration :duration, category: REQUEST_CATEGORIZER, title: 'Request duration',    line_type: :completed
+      analyze.duration :view,     category: REQUEST_CATEGORIZER, title: 'View rendering time', line_type: :completed
+      analyze.duration :db,       category: REQUEST_CATEGORIZER, title: 'Database time',       line_type: :completed
+
+      analyze.frequency category: REQUEST_CATEGORIZER, title: 'Process blockers (> 1 sec duration)',
+        if: lambda { |request| request[:duration] && request[:duration] > 1.0 }
+
+      if lines.key?(:failure)
+        analyze.frequency :error, title: 'Failed requests', line_type: :failure
       end
 
-      if lines.has_key?(:rendered)
-        analyze.duration :render_duration, :category => :render_file, :multiple => true, :title => 'Partial rendering duration'
+      if lines.key?(:rendered)
+        analyze.duration :render_duration, category: :render_file, multiple: true, title: 'Partial rendering duration'
       end
 
-      if lines.has_key?(:query_executed)
-        analyze.duration :query_duration, :category => :query_sql, :multiple => true, :title => 'Query duration'
+      if lines.key?(:query_executed)
+        analyze.duration :query_duration, category: :query_sql, multiple: true, title: 'Query duration'
       end
-      
-      return analyze.trackers + report_definer.trackers
+
+      analyze.trackers + report_definer.trackers
     end
 
     # Rails < 2.1 completed line example
@@ -83,92 +81,90 @@ module RequestLogAnalyzer::FileFormat
     # Rails > 2.1 completed line example
     # Completed in 614ms (View: 120, DB: 31) | 200 OK [http://floorplanner.local/demo]
     RAILS_22_COMPLETED = /Completed in (\d+)ms \((?:View: (\d+))?,?(?:.?DB: (\d+))?\)? \| (\d{3}).+\[(http.+)\]/
-                        
+
     # A hash of definitions for all common lines in Rails logs.
     LINE_DEFINITIONS = {
-      :processing => RequestLogAnalyzer::LineDefinition.new(:processing, :header => true,
-            :teaser   => /Processing /,
-            :regexp   => /Processing ((?:\w+::)*\w+)#(\w+)(?: to (\w+))? \(for (#{ip_address}) at (#{timestamp('%Y-%m-%d %H:%M:%S')})\) \[([A-Z]+)\]/,
-            :captures => [{ :name => :controller, :type  => :string },
-                          { :name => :action,     :type  => :string },
-                          { :name => :format,     :type  => :string, :default => 'html' },
-                          { :name => :ip,         :type  => :string },
-                          { :name => :timestamp,  :type  => :timestamp },
-                          { :name => :method,     :type  => :string }]),
-
-      :completed => RequestLogAnalyzer::LineDefinition.new(:completed, :footer => true,
-            :teaser   => /Completed in /,
-            :regexp   => Regexp.union(RAILS_21_COMPLETED, RAILS_22_COMPLETED),
-            :captures => [{ :name => :duration, :type => :duration, :unit => :sec },   # First old variant capture
-                          { :name => :view,     :type => :duration, :unit => :sec },
-                          { :name => :db,       :type => :duration, :unit => :sec },
-                          { :name => :status,   :type => :integer },
-                          { :name => :url,      :type => :string },                    # Last old variant capture
-                          { :name => :duration, :type => :duration, :unit => :msec },  # First new variant capture
-                          { :name => :view,     :type => :duration, :unit => :msec },
-                          { :name => :db,       :type => :duration, :unit => :msec },
-                          { :name => :status,   :type => :integer },
-                          { :name => :url,      :type => :string }]),                  # Last new variant capture
-
-      :failure => RequestLogAnalyzer::LineDefinition.new(:failure, :footer => true,
-          :teaser   => /((?:[A-Z]\w*[a-z]\w+\:\:)*[A-Z]\w*[a-z]\w+) \((.*)\)(?: on line #(\d+) of (.+))?\:/,
-          :regexp   => /((?:[A-Z]\w*[a-z]\w+\:\:)*[A-Z]\w*[a-z]\w+) \((.*)\)(?: on line #(\d+) of (.+))?\:\s*$/,
-          :captures => [{ :name => :error,       :type => :string },
-                        { :name => :message,     :type => :string },
-                        { :name => :line,        :type => :integer },
-                        { :name => :file,        :type => :string }]),
-
-      :cache_hit => RequestLogAnalyzer::LineDefinition.new(:cache_hit,
-          :regexp => /Filter chain halted as \[\#<ActionController::Filters::AroundFilter.*\@method=.*(?:Caching::Actions::ActionCacheFilter|action_controller\/caching\/actions\.rb).*\] did_not_yield/),
-
-      :parameters => RequestLogAnalyzer::LineDefinition.new(:parameters,
-          :teaser   => /  Parameters:/,
-          :regexp   => /  Parameters:\s+(\{.*\})/,
-          :captures => [{ :name => :params, :type => :eval }]),
-
-      :rendered => RequestLogAnalyzer::LineDefinition.new(:rendered,
-          :teaser   => /Rendered /,
-          :regexp   => /Rendered (\w+(?:\/\w+)+) \((\d+\.\d+)ms\)/,
-          :captures => [{ :name => :render_file,     :type  => :string },
-                        { :name => :render_duration, :type  => :duration, :unit => :msec }]),
-
-      :query_executed => RequestLogAnalyzer::LineDefinition.new(:query_executed,
-          :regexp   => /\s+(?:\e\[4;36;1m)?((?:\w+::)*\w+) Load \((\d+\.\d+)ms\)(?:\e\[0m)?\s+(?:\e\[0;1m)?([^\e]+) ?(?:\e\[0m)?/,
-          :captures => [{ :name => :query_class,    :type  => :string },
-                        { :name => :query_duration, :type  => :duration, :unit => :msec },
-                        { :name => :query_sql,      :type  => :sql }]),
-
-      :query_cached => RequestLogAnalyzer::LineDefinition.new(:query_cached,
-          :regexp   => /\s+(?:\e\[4;35;1m)?CACHE \((\d+\.\d+)ms\)(?:\e\[0m)?\s+(?:\e\[0m)?([^\e]+) ?(?:\e\[0m)?/,
-          :captures => [{ :name => :cached_duration, :type  => :duration, :unit => :msec },
-                        { :name => :cached_sql,      :type  => :sql }])
+      processing: RequestLogAnalyzer::LineDefinition.new(:processing, header: true,
+                                                                      teaser: /Processing /,
+                                                                      regexp: /Processing ((?:\w+::)*\w+)#(\w+)(?: to (\w+))? \(for (#{ip_address}) at (#{timestamp('%Y-%m-%d %H:%M:%S')})\) \[([A-Z]+)\]/,
+                                                                      captures: [{ name: :controller, type: :string },
+                                                                                 { name: :action,     type: :string },
+                                                                                 { name: :format,     type: :string, default: 'html' },
+                                                                                 { name: :ip,         type: :string },
+                                                                                 { name: :timestamp,  type: :timestamp },
+                                                                                 { name: :method,     type: :string }]),
+
+      completed: RequestLogAnalyzer::LineDefinition.new(:completed, footer: true,
+                                                                    teaser: /Completed in /,
+                                                                    regexp: Regexp.union(RAILS_21_COMPLETED, RAILS_22_COMPLETED),
+                                                                    captures: [{ name: :duration, type: :duration, unit: :sec },   # First old variant capture
+                                                                               { name: :view,     type: :duration, unit: :sec },
+                                                                               { name: :db,       type: :duration, unit: :sec },
+                                                                               { name: :status,   type: :integer },
+                                                                               { name: :url,      type: :string },                    # Last old variant capture
+                                                                               { name: :duration, type: :duration, unit: :msec },  # First new variant capture
+                                                                               { name: :view,     type: :duration, unit: :msec },
+                                                                               { name: :db,       type: :duration, unit: :msec },
+                                                                               { name: :status,   type: :integer },
+                                                                               { name: :url,      type: :string }]),                  # Last new variant capture
+
+      failure: RequestLogAnalyzer::LineDefinition.new(:failure, footer: true,
+                                                                teaser: /((?:[A-Z]\w*[a-z]\w+\:\:)*[A-Z]\w*[a-z]\w+) \((.*)\)(?: on line #(\d+) of (.+))?\:/,
+                                                                regexp: /((?:[A-Z]\w*[a-z]\w+\:\:)*[A-Z]\w*[a-z]\w+) \((.*)\)(?: on line #(\d+) of (.+))?\:\s*$/,
+                                                                captures: [{ name: :error,       type: :string },
+                                                                           { name: :message,     type: :string },
+                                                                           { name: :line,        type: :integer },
+                                                                           { name: :file,        type: :string }]),
+
+      cache_hit: RequestLogAnalyzer::LineDefinition.new(:cache_hit,
+                                                        regexp: /Filter chain halted as \[\#<ActionController::Filters::AroundFilter.*\@method=.*(?:Caching::Actions::ActionCacheFilter|action_controller\/caching\/actions\.rb).*\] did_not_yield/),
+
+      parameters: RequestLogAnalyzer::LineDefinition.new(:parameters,
+                                                         teaser: /  Parameters:/,
+                                                         regexp: /  Parameters:\s+(\{.*\})/,
+                                                         captures: [{ name: :params, type: :eval }]),
+
+      rendered: RequestLogAnalyzer::LineDefinition.new(:rendered,
+                                                       teaser: /Rendered /,
+                                                       regexp: /Rendered (\w+(?:\/\w+)+) \((\d+\.\d+)ms\)/,
+                                                       captures: [{ name: :render_file,     type: :string },
+                                                                  { name: :render_duration, type: :duration, unit: :msec }]),
+
+      query_executed: RequestLogAnalyzer::LineDefinition.new(:query_executed,
+                                                             regexp: /\s+(?:\e\[4;36;1m)?((?:\w+::)*\w+) Load \((\d+\.\d+)ms\)(?:\e\[0m)?\s+(?:\e\[0;1m)?([^\e]+) ?(?:\e\[0m)?/,
+                                                             captures: [{ name: :query_class,    type: :string },
+                                                                        { name: :query_duration, type: :duration, unit: :msec },
+                                                                        { name: :query_sql,      type: :sql }]),
+
+      query_cached: RequestLogAnalyzer::LineDefinition.new(:query_cached,
+                                                           regexp: /\s+(?:\e\[4;35;1m)?CACHE \((\d+\.\d+)ms\)(?:\e\[0m)?\s+(?:\e\[0m)?([^\e]+) ?(?:\e\[0m)?/,
+                                                           captures: [{ name: :cached_duration, type: :duration, unit: :msec },
+                                                                      { name: :cached_sql,      type: :sql }])
     }
 
     # Definitions of common combinations of lines that can be parsed
     LINE_COLLECTIONS = {
-      :minimal     => [:processing, :completed],
-      :production  => [:processing, :completed, :failure, :cache_hit],
-      :development => [:processing, :completed, :failure, :rendered, :query_executed, :query_cached],
-      :all         => LINE_DEFINITIONS.keys
+      minimal: [:processing, :completed],
+      production: [:processing, :completed, :failure, :cache_hit],
+      development: [:processing, :completed, :failure, :rendered, :query_executed, :query_cached],
+      all: LINE_DEFINITIONS.keys
     }
 
-
     # Simple function to categorize Rails requests using controller/actions/format and method.
-    REQUEST_CATEGORIZER = Proc.new do |request|
+    REQUEST_CATEGORIZER = proc do |request|
       "#{request[:controller]}##{request[:action]}.#{request[:format]} [#{request[:method]}]"
     end
 
     # Define a custom Request class for the Rails file format to speed up timestamp handling
     # and to ensure that a format is always set.
     class Request < RequestLogAnalyzer::Request
-
       # Do not use DateTime.parse
-      def convert_timestamp(value, definition)
+      def convert_timestamp(value, _definition)
         value.gsub(/[^0-9]/, '')[0...14].to_i
       end
 
       # Sanitizes SQL queries so that they can be grouped
-      def convert_sql(sql, definition)
+      def convert_sql(sql, _definition)
         sql.gsub(/\b\d+\b/, ':int').gsub(/`([^`]+)`/, '\1').gsub(/'[^']*'/, ':string').rstrip
       end
     end

data/lib/request_log_analyzer/file_format/rails3.rb

@@ -1,11 +1,9 @@
 module RequestLogAnalyzer::FileFormat
-
   # Default FileFormat class for Rails 3 logs.
   #
   # For now, this is just a basic implementation. It will probaby change after
   # Rails 3 final has been released.
   class Rails3 < Base
-
     extend CommonRegularExpressions
 
     # beta4: Started GET "/" for 127.0.0.1 at Wed Jul 07 09:13:27 -0700 2010 (different time format)
@@ -46,9 +44,9 @@ module RequestLogAnalyzer::FileFormat
       line.regexp = /Completed (\d+)? .*in (\d+(?:\.\d+)?)ms(?:[^\(]*\(Views: (\d+(?:\.\d+)?)ms .* ActiveRecord: (\d+(?:\.\d+)?)ms.*\))?/
 
       line.capture(:status).as(:integer)
-      line.capture(:duration).as(:duration, :unit => :msec)
-      line.capture(:view).as(:duration, :unit => :msec)
-      line.capture(:db).as(:duration, :unit => :msec)
+      line.capture(:duration).as(:duration, unit: :msec)
+      line.capture(:view).as(:duration, unit: :msec)
+      line.capture(:db).as(:duration, unit: :msec)
     end
 
     # ActionController::RoutingError (No route matches [GET] "/missing_stuff"):
@@ -76,7 +74,7 @@ module RequestLogAnalyzer::FileFormat
       line.teaser = /\bRendered /
       line.regexp = /\bRendered ([a-zA-Z0-9_\-\/.]+(?:\/[a-zA-Z0-9_\-.]+)+)(?:\ within\ .*?)? \((\d+(?:\.\d+)?)ms\)/
       line.capture(:rendered_file)
-      line.capture(:partial_duration).as(:duration, :unit => :msec)
+      line.capture(:partial_duration).as(:duration, unit: :msec)
     end
 
     # # Not parsed at the moment:
@@ -91,46 +89,44 @@ module RequestLogAnalyzer::FileFormat
       analyze.timespan
       analyze.hourly_spread
 
-      analyze.frequency :category => REQUEST_CATEGORIZER, :title => 'Most requested'
-      analyze.frequency :method, :title => 'HTTP methods'
-      analyze.frequency :status, :title => 'HTTP statuses returned'
+      analyze.frequency category: REQUEST_CATEGORIZER, title: 'Most requested'
+      analyze.frequency :method, title: 'HTTP methods'
+      analyze.frequency :status, title: 'HTTP statuses returned'
 
-      analyze.duration :duration, :category => REQUEST_CATEGORIZER, :title => "Request duration", :line_type => :completed
-      analyze.duration :partial_duration, :category => :rendered_file, :title => 'Partials rendering time', :line_type => :rendered
-      analyze.duration :view, :category => REQUEST_CATEGORIZER, :title => "View rendering time", :line_type => :completed
-      analyze.duration :db, :category => REQUEST_CATEGORIZER, :title => "Database time", :line_type => :completed
+      analyze.duration :duration, category: REQUEST_CATEGORIZER, title: 'Request duration', line_type: :completed
+      analyze.duration :partial_duration, category: :rendered_file, title: 'Partials rendering time', line_type: :rendered
+      analyze.duration :view, category: REQUEST_CATEGORIZER, title: 'View rendering time', line_type: :completed
+      analyze.duration :db, category: REQUEST_CATEGORIZER, title: 'Database time', line_type: :completed
 
-      analyze.frequency :category => REQUEST_CATEGORIZER, :title => 'Process blockers (> 1 sec duration)',
-        :if => lambda { |request| request[:duration] && request[:duration] > 1.0 }
+      analyze.frequency category: REQUEST_CATEGORIZER, title: 'Process blockers (> 1 sec duration)',
+        if: lambda { |request| request[:duration] && request[:duration] > 1.0 }
 
-      analyze.frequency :category => lambda{|x| "[#{x[:missing_resource_method]}] #{x[:missing_resource]}"},
-        :title => "Routing Errors", :if => lambda{ |request| !request[:missing_resource].nil? }
+      analyze.frequency category: lambda { |x| "[#{x[:missing_resource_method]}] #{x[:missing_resource]}" },
+        title: 'Routing Errors', if: lambda { |request| !request[:missing_resource].nil? }
     end
 
     class Request < RequestLogAnalyzer::Request
       # Used to handle conversion of abbrev. month name to a digit
       MONTHS = %w(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec)
 
-      def convert_timestamp(value, definition)
+      def convert_timestamp(value, _definition)
         # the time value can be in 2 formats:
         # - 2010-10-26 02:27:15 +0000 (ruby 1.9.2)
         # - Thu Oct 25 16:15:18 -0800 2010
         if value =~ /^#{CommonRegularExpressions::TIMESTAMP_PARTS['Y']}/
-          value.gsub!(/\W/,'')
+          value.gsub!(/\W/, '')
           value[0..13].to_i
         else
-          value.gsub!(/\W/,'')
+          value.gsub!(/\W/, '')
           time_as_str = value[-4..-1] # year
           # convert the month to a 2-digit representation
-          month = MONTHS.index(value[3..5])+1
+          month = MONTHS.index(value[3..5]) + 1
           month < 10 ? time_as_str << "0#{month}" : time_as_str << month.to_s
 
           time_as_str << value[6..13] # day of month + time
           time_as_str.to_i
         end
-
       end
     end
-
   end
 end

data/lib/request_log_analyzer/file_format/rails_development.rb

@@ -1,5 +1,4 @@
 module RequestLogAnalyzer::FileFormat
-
   # The RailsDevelopment FileFormat is an extention to the default Rails file format. It includes
   # all lines of the normal Rails file format, but parses SQL queries and partial rendering lines
   # as well.