request-log-analyzer 1.13.1 → 1.13.3

data/lib/request_log_analyzer/database.rb

@@ -2,7 +2,6 @@ require 'rubygems'
 require 'active_record'
 
 class RequestLogAnalyzer::Database
-
   require 'request_log_analyzer/database/connection'
   include RequestLogAnalyzer::Database::Connection
 
@@ -45,7 +44,6 @@ class RequestLogAnalyzer::Database
   # Loads an ActiveRecord-based class that correspond to the given parameter, which can either be
   # a table name or a LineDefinition instance.
   def load_activerecord_class(linedefinition_or_table)
-
     case linedefinition_or_table
     when String, Symbol
       klass_name = linedefinition_or_table.to_s.singularize.camelize
@@ -58,13 +56,13 @@ class RequestLogAnalyzer::Database
     Object.const_set(klass_name, klass)
     klass = Object.const_get(klass_name)
     @line_classes << klass
-    return klass
+    klass
   end
 
   def fileformat_classes
-    raise "No file_format provided!" unless file_format
-    line_classes    = file_format.line_definitions.map { |(name, definition)| load_activerecord_class(definition) }
-    return default_classes + line_classes
+    fail 'No file_format provided!' unless file_format
+    line_classes    = file_format.line_definitions.map { |(_name, definition)| load_activerecord_class(definition) }
+    default_classes + line_classes
   end
 
   # Creates the database schema and related ActiveRecord::Base subclasses that correspond to the

data/lib/request_log_analyzer/database/base.rb

@@ -1,5 +1,4 @@
 class RequestLogAnalyzer::Database::Base < ActiveRecord::Base
-
   self.abstract_class = true
 
   def <=>(other)
@@ -9,14 +8,14 @@ class RequestLogAnalyzer::Database::Base < ActiveRecord::Base
       source_comparison
     end
   end
-  
+
   # Handle format manually, because it is prohibidado in Rails 3.2.1
   def format=(arg)
-    self.attributes[:format] = arg
+    attributes[:format] = arg
   end
-  
-  def format(arg)
-    self.attributes[:format]
+
+  def format(_arg)
+    attributes[:format]
   end
 
   def line_type
@@ -32,46 +31,46 @@ class RequestLogAnalyzer::Database::Base < ActiveRecord::Base
     klass.line_definition = definition
 
     # Set relations with requests and sources table
-    klass.belongs_to :request, :class_name => RequestLogAnalyzer::Database::Request.name
-    klass.belongs_to :source, :class_name => RequestLogAnalyzer::Database::Source.name
+    klass.belongs_to :request, class_name: RequestLogAnalyzer::Database::Request.name
+    klass.belongs_to :source, class_name: RequestLogAnalyzer::Database::Source.name
 
     # Serialize complex fields into the database
-    definition.captures.select { |c| c.has_key?(:provides) }.each do |capture|
+    definition.captures.select { |c| c.key?(:provides) }.each do |capture|
       klass.send(:serialize, capture[:name], Hash)
     end
 
-    RequestLogAnalyzer::Database::Request.has_many  "#{definition.name}_lines".to_sym
-    RequestLogAnalyzer::Database::Source.has_many   "#{definition.name}_lines".to_sym
+    RequestLogAnalyzer::Database::Request.has_many "#{definition.name}_lines".to_sym
+    RequestLogAnalyzer::Database::Source.has_many "#{definition.name}_lines".to_sym
 
-    return klass
+    klass
   end
 
   def self.subclass_from_table(table, klass = Class.new(RequestLogAnalyzer::Database::Base))
-    raise "Table #{table} not found!" unless database.connection.table_exists?(table)
-    
+    fail "Table #{table} not found!" unless database.connection.table_exists?(table)
+
     klass.table_name = table
 
     if klass.column_names.include?('request_id')
-      klass.belongs_to :request, :class_name => RequestLogAnalyzer::Database::Request.name
+      klass.belongs_to :request, class_name: RequestLogAnalyzer::Database::Request.name
       RequestLogAnalyzer::Database::Request.has_many table.to_sym
     end
 
     if klass.column_names.include?('source_id')
-      klass.belongs_to :source, :class_name => RequestLogAnalyzer::Database::Source.name
+      klass.belongs_to :source, class_name: RequestLogAnalyzer::Database::Source.name
       RequestLogAnalyzer::Database::Source.has_many table.to_sym
     end
 
-    return klass
+    klass
   end
 
   def self.drop_table!
-    database.connection.remove_index(self.table_name, [:source_id])  rescue nil
-    database.connection.remove_index(self.table_name, [:request_id]) rescue nil
-    database.connection.drop_table(self.table_name) if database.connection.table_exists?(self.table_name)
+    database.connection.remove_index(table_name, [:source_id])  rescue nil
+    database.connection.remove_index(table_name, [:request_id]) rescue nil
+    database.connection.drop_table(table_name) if database.connection.table_exists?(table_name)
   end
 
   def self.create_table!
-    raise "No line_definition available to base table schema on!" unless self.line_definition
+    fail 'No line_definition available to base table schema on!' unless line_definition
 
     unless table_exists?
       database.connection.create_table(table_name.to_sym) do |t|
@@ -88,13 +87,13 @@ class RequestLogAnalyzer::Database::Base < ActiveRecord::Base
           t.column(column_name, column_type(capture[:type]))
 
           # If the capture provides other field as well, create columns for them, too
-          capture[:provides].each { |field, field_type| t.column(field, column_type(field_type)) } if capture[:provides].kind_of?(Hash)
+          capture[:provides].each { |field, field_type| t.column(field, column_type(field_type)) } if capture[:provides].is_a?(Hash)
         end
       end
-      
+
       # Add indices to table for more speedy querying
-      database.connection.add_index(self.table_name.to_sym, [:request_id]) # rescue
-      database.connection.add_index(self.table_name.to_sym, [:source_id])  # rescue
+      database.connection.add_index(table_name.to_sym, [:request_id]) # rescue
+      database.connection.add_index(table_name.to_sym, [:source_id])  # rescue
     end
   end
 
@@ -102,22 +101,21 @@ class RequestLogAnalyzer::Database::Base < ActiveRecord::Base
   # TODO: make more robust / include in file-format definition
   def self.column_type(type_indicator)
     case type_indicator
-    when :eval;      :text
-    when :hash;      :text
-    when :text;      :text
-    when :string;    :string
-    when :sec;       :float
-    when :msec;      :float
-    when :duration;  :float
-    when :float;     :float
-    when :double;    :float
-    when :integer;   :integer
-    when :int;       :int
-    when :timestamp; :datetime
-    when :datetime;  :datetime
-    when :date;      :date
+    when :eval then      :text
+    when :hash then      :text
+    when :text then      :text
+    when :string then    :string
+    when :sec then       :float
+    when :msec then      :float
+    when :duration then  :float
+    when :float then     :float
+    when :double then    :float
+    when :integer then   :integer
+    when :int then       :int
+    when :timestamp then :datetime
+    when :datetime then  :datetime
+    when :date then      :date
     else             :string
     end
   end
-
-end
+end

data/lib/request_log_analyzer/database/connection.rb

@@ -1,29 +1,28 @@
 module RequestLogAnalyzer::Database::Connection
-
   def self.from_string(string)
     hash = {}
     if string =~ /^(?:\w+=(?:[^;])*;)*\w+=(?:[^;])*$/
       string.scan(/(\w+)=([^;]*);?/) { |variable, value| hash[variable.to_sym] = value }
     elsif string =~ /^(\w+)\:\/\/(?:(?:([^:]+)(?:\:([^:]+))?\@)?([\w\.-]+)\/)?([\w\:\-\.\/]+)$/
-      hash[:adapter], hash[:username], hash[:password], hash[:host], hash[:database] = $1, $2, $3, $4, $5
-      hash.delete_if { |k, v| v.nil? }
+      hash[:adapter], hash[:username], hash[:password], hash[:host], hash[:database] = Regexp.last_match[1], Regexp.last_match[2], Regexp.last_match[3], Regexp.last_match[4], Regexp.last_match[5]
+      hash.delete_if { |_k, v| v.nil? }
     end
-    return hash.empty? ? nil : hash
+    hash.empty? ? nil : hash
   end
 
   def connect(connection_identifier)
-    if connection_identifier.kind_of?(Hash)
+    if connection_identifier.is_a?(Hash)
       ActiveRecord::Base.establish_connection(connection_identifier)
     elsif connection_identifier == ':memory:'
-      ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+      ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
     elsif connection_hash = RequestLogAnalyzer::Database::Connection.from_string(connection_identifier)
       ActiveRecord::Base.establish_connection(connection_hash)
-    elsif connection_identifier.kind_of?(String) # Normal SQLite 3 database file
-      ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => connection_identifier)
+    elsif connection_identifier.is_a?(String) # Normal SQLite 3 database file
+      ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: connection_identifier)
     elsif connection_identifier.nil?
       nil
     else
-      raise "Cannot connect with this connection_identifier: #{connection_identifier.inspect}"
+      fail "Cannot connect with this connection_identifier: #{connection_identifier.inspect}"
     end
   end
 
@@ -34,5 +33,4 @@ module RequestLogAnalyzer::Database::Connection
   def connection
     RequestLogAnalyzer::Database::Base.connection
   end
-
 end

data/lib/request_log_analyzer/database/request.rb

@@ -1,10 +1,9 @@
 class RequestLogAnalyzer::Database::Request < RequestLogAnalyzer::Database::Base
-
   # Returns an array of all the Line objects of this request in the correct order.
   def lines
     @lines ||= begin
       lines = []
-      self.class.reflections.each { |r, d| lines += self.send(r).all }
+      self.class.reflections.each { |r, _d| lines += send(r).all }
       lines.sort
     end
   end
@@ -18,5 +17,4 @@ class RequestLogAnalyzer::Database::Request < RequestLogAnalyzer::Database::Base
       end
     end
   end
-
 end

data/lib/request_log_analyzer/database/source.rb

@@ -1,5 +1,4 @@
 class RequestLogAnalyzer::Database::Source < RequestLogAnalyzer::Database::Base
-
   def self.create_table!
     unless database.connection.table_exists?(:sources)
       database.connection.create_table(:sources) do |t|
@@ -9,5 +8,4 @@ class RequestLogAnalyzer::Database::Source < RequestLogAnalyzer::Database::Base
       end
     end
   end
-
 end

data/lib/request_log_analyzer/database/warning.rb

@@ -1,14 +1,12 @@
 class RequestLogAnalyzer::Database::Warning < RequestLogAnalyzer::Database::Base
-
   def self.create_table!
     unless database.connection.table_exists?(:warnings)
       database.connection.create_table(:warnings) do |t|
-        t.column  :warning_type, :string, :limit => 30, :null => false
-        t.column  :message, :string
-        t.column  :source_id, :integer
-        t.column  :lineno, :integer
+        t.column :warning_type, :string, limit: 30, null: false
+        t.column :message, :string
+        t.column :source_id, :integer
+        t.column :lineno, :integer
       end
     end
   end
-
 end

data/lib/request_log_analyzer/file_format.rb

@@ -1,7 +1,6 @@
 require 'request_log_analyzer/request'
 
 module RequestLogAnalyzer::FileFormat
-
   autoload :Rails,            'request_log_analyzer/file_format/rails'
   autoload :Rails3,           'request_log_analyzer/file_format/rails3'
   autoload :RailsDevelopment, 'request_log_analyzer/file_format/rails_development'
@@ -29,15 +28,15 @@ module RequestLogAnalyzer::FileFormat
   # * A symbol of a built-in file format (e.g. :rails)
   def self.load(file_format, *args)
     klass = nil
-    if file_format.kind_of?(RequestLogAnalyzer::FileFormat::Base)
+    if file_format.is_a?(RequestLogAnalyzer::FileFormat::Base)
       # this already is a file format! return itself
       return @current_file_format = file_format
 
-    elsif file_format.kind_of?(Class) && file_format.ancestors.include?(RequestLogAnalyzer::FileFormat::Base)
+    elsif file_format.is_a?(Class) && file_format.ancestors.include?(RequestLogAnalyzer::FileFormat::Base)
       # a usable class is provided. Use this format class.
       klass = file_format
 
-    elsif file_format.kind_of?(String) && File.exist?(file_format) && File.file?(file_format)
+    elsif file_format.is_a?(String) && File.exist?(file_format) && File.file?(file_format)
       # load a format from a ruby file
       require File.expand_path(file_format)
 
@@ -47,7 +46,7 @@ module RequestLogAnalyzer::FileFormat
       elsif Object.const_defined?(const)
         klass = Object.const_get(const)
       else
-        raise "Cannot load class #{const} from #{file_format}!"
+        fail "Cannot load class #{const} from #{file_format}!"
       end
 
     else
@@ -56,19 +55,19 @@ module RequestLogAnalyzer::FileFormat
     end
 
     # check the returned klass to see if it can be used
-    raise "Could not load a file format from #{file_format.inspect}" if klass.nil?
-    raise "Invalid FileFormat class from #{file_format.inspect}" unless klass.kind_of?(Class) && klass.ancestors.include?(RequestLogAnalyzer::FileFormat::Base)
+    fail "Could not load a file format from #{file_format.inspect}" if klass.nil?
+    fail "Invalid FileFormat class from #{file_format.inspect}" unless klass.is_a?(Class) && klass.ancestors.include?(RequestLogAnalyzer::FileFormat::Base)
 
     @current_file_format = klass.create(*args) # return an instance of the class
   end
-  
+
   # Returns an array of all FileFormat instances that are shipped with request-log-analyzer by default.
   def self.all_formats
-    @all_formats ||= Dir[File.expand_path('file_format/*.rb', File.dirname(__FILE__))].map do |file| 
-      self.load(File.basename(file, '.rb')) 
+    @all_formats ||= Dir[File.expand_path('file_format/*.rb', File.dirname(__FILE__))].map do |file|
+      load(File.basename(file, '.rb'))
     end
   end
-  
+
   # Autodetects the filetype of a given file.
   #
   # Returns a FileFormat instance, by parsing the first couple of lines of the provided file
@@ -78,18 +77,17 @@ module RequestLogAnalyzer::FileFormat
   # <tt>file</tt>:: The file to detect the file format for.
   # <tt>line_count</tt>:: The number of lines to take into consideration
   def self.autodetect(file, line_count = 50)
-    
-    parsers = all_formats.map { |f| RequestLogAnalyzer::Source::LogParser.new(f, :parse_strategy => 'cautious') }
-    
+    parsers = all_formats.map { |f| RequestLogAnalyzer::Source::LogParser.new(f, parse_strategy: 'cautious') }
+
     File.open(file, 'rb') do |io|
       while io.lineno < line_count && (line = io.gets)
-        parsers.each { |parser| parser.parse_line(line) } 
+        parsers.each { |parser| parser.parse_line(line) }
       end
     end
-    
+
     parsers.select { |p| autodetect_score(p) > 0 }.max { |a, b| autodetect_score(a) <=> autodetect_score(b) }.file_format rescue nil
   end
-  
+
   # Calculates a file format auto detection score based on the parser statistics.
   #
   # This method returns a score as an integer. Usually, the score will increase as more
@@ -113,10 +111,9 @@ module RequestLogAnalyzer::FileFormat
   # This module contains some methods to construct regular expressions for log fragments
   # that are commonly used, like IP addresses and timestamp.
   #
-  # You need to extend (or include in an unlikely case) this module in your file format 
+  # You need to extend (or include in an unlikely case) this module in your file format
   # to use these regular expression constructors.
   module CommonRegularExpressions
-
     TIMESTAMP_PARTS = {
       'a' => '(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)',
       'b' => '(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)',
@@ -126,13 +123,13 @@ module RequestLogAnalyzer::FileFormat
       'Z' => '(?:[+-]\d{4}|[A-Z]{3,4})',
       '%' => '%'
     }
-    
+
     # Creates a regular expression to match a hostname
     def hostname(blank = false)
       regexp = /(?:(?:[a-zA-Z]|[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*(?:[A-Za-z]|[A-Za-z][A-Za-z0-9\-]*[A-Za-z0-9])/
       add_blank_option(regexp, blank)
     end
-    
+
     # Creates a regular expression to match a hostname or ip address
     def hostname_or_ip_address(blank = false)
       regexp = Regexp.union(hostname, ip_address)
@@ -148,10 +145,10 @@ module RequestLogAnalyzer::FileFormat
       format_string.scan(/([^%]*)(?:%([A-Za-z%]))?/) do |literal, variable|
         regexp << Regexp.quote(literal)
         if variable
-          if TIMESTAMP_PARTS.has_key?(variable)
+          if TIMESTAMP_PARTS.key?(variable)
             regexp << TIMESTAMP_PARTS[variable]
           else
-            raise "Unknown variable: %#{variable}"
+            fail "Unknown variable: %#{variable}"
           end
         end
       end
@@ -161,11 +158,10 @@ module RequestLogAnalyzer::FileFormat
 
     # Construct a regular expression to parse IPv4 and IPv6 addresses.
     #
-    # Allow nil values if the blank option is given. This can be true to 
+    # Allow nil values if the blank option is given. This can be true to
     # allow an empty string or to a string substitute for the nil value.
     def ip_address(blank = false)
-
-      # IP address regexp copied from Resolv::IPv4 and Resolv::IPv6, 
+      # IP address regexp copied from Resolv::IPv4 and Resolv::IPv6,
       # but adjusted to work for the purpose of request-log-analyzer.
       ipv4_regexp                     = /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/
       ipv6_regex_8_hex                = /(?:[0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4}/
@@ -176,19 +172,19 @@ module RequestLogAnalyzer::FileFormat
 
       add_blank_option(Regexp.union(ipv4_regexp, ipv6_regexp), blank)
     end
-    
+
     def anchored(regexp)
       /^#{regexp}$/
     end
-    
+
     protected
-    
-    # Allow the field to be blank if this option is given. This can be true to 
+
+    # Allow the field to be blank if this option is given. This can be true to
     # allow an empty string or a string alternative for the nil value.
     def add_blank_option(regexp, blank)
       case blank
-        when String; Regexp.union(regexp, Regexp.new(Regexp.quote(blank)))
-        when true;   Regexp.union(regexp, //)
+        when String then Regexp.union(regexp, Regexp.new(Regexp.quote(blank)))
+        when true then   Regexp.union(regexp, //)
         else regexp
       end
     end
@@ -200,6 +196,8 @@ module RequestLogAnalyzer::FileFormat
   # A subclass of this class is instantiated when request-log-analyzer is started and this instance
   # is shared with all components of the application so they can act on the specifics of the format
   class Base
+    extend RequestLogAnalyzer::ClassLevelInheritableAttributes
+    inheritable_attributes :line_definer, :report_definer
 
     attr_reader :line_definitions, :report_trackers
 
@@ -213,18 +211,18 @@ module RequestLogAnalyzer::FileFormat
     end
 
     # Specifies multiple line definitions at once using a block
-    def self.format_definition(&block)
+    def self.format_definition(&_block)
       if block_given?
-        yield self.line_definer
+        yield line_definer
       else
-        return self.line_definer
+        return line_definer
       end
     end
 
     # Specifies the summary report using a block.
-    def self.report(mode = :append, &block)
-      self.report_definer.reset! if mode == :overwrite
-      yield(self.report_definer)
+    def self.report(mode = :append, &_block)
+      report_definer.reset! if mode == :overwrite
+      yield(report_definer)
     end
 
     # Setup the default line definer.
@@ -244,9 +242,9 @@ module RequestLogAnalyzer::FileFormat
     # Instantiation
     ####################################################################################
 
-    def self.create(*args)
+    def self.create(*_args)
       # Ignore arguments
-      return self.new(line_definer.line_definitions, report_definer.trackers)
+      new(line_definer.line_definitions, report_definer.trackers)
     end
 
     def initialize(line_definitions = {}, report_trackers = [])
@@ -271,16 +269,15 @@ module RequestLogAnalyzer::FileFormat
     def well_formed?
       valid_line_definitions? && valid_request_class?
     end
-    
+
     alias_method :valid?, :well_formed?
-  
 
     # Checks whether the line definitions form a valid language.
-    # A file format should have at least a header and a footer line type    
+    # A file format should have at least a header and a footer line type
     def valid_line_definitions?
       line_definitions.any? { |(_, ld)| ld.header } && line_definitions.any? { |(_, ld)| ld.footer }
     end
-    
+
     # Checks whether the request class inherits from the base Request class.
     def valid_request_class?
       request_class.ancestors.include?(RequestLogAnalyzer::Request)
@@ -293,24 +290,24 @@ module RequestLogAnalyzer::FileFormat
 
     # Function that a file format con implement to monkey patch the environment.
     # * <tt>controller</tt> The environment is provided as a controller instance
-    def setup_environment(controller)
+    def setup_environment(_controller)
     end
 
     # Parses a line by trying to parse it using every line definition in this file format
     def parse_line(line, &warning_handler)
-      self.line_definitions.each do |lt, definition|
+      line_definitions.each do |_lt, definition|
         match = definition.matches(line, &warning_handler)
         return match if match
       end
 
-      return nil
+      nil
     end
-    
+
     # Returns the max line length for this file format if any.
     def max_line_length
       self.class.const_get(MAX_LINE_LENGTH) if self.class.const_defined?(:MAX_LINE_LENGTH)
     end
-    
+
     def line_divider
       self.class.const_get(LINE_DIVIDER) if self.class.const_defined?(:LINE_DIVIDER)
     end