adlint 2.6.14 → 3.0.0

data/lib/adlint/message.rb

@@ -1,7 +1,7 @@
 # Base classes of the warning and the error messages.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -29,40 +29,116 @@
 #
 #++
 
-require "adlint/traits"
 require "adlint/token"
 require "adlint/error"
-require "adlint/version"
 
 module AdLint #:nodoc:
 
+  class MessageId
+    def initialize(pkg_name, msg_name)
+      @package_name = pkg_name
+      @message_name = msg_name
+    end
+
+    attr_reader :package_name
+    attr_reader :message_name
+
+    def qualified?
+      !@package_name.nil?
+    end
+
+    def ==(rhs)
+      self.eql?(rhs)
+    end
+
+    def eql?(rhs)
+      if self.qualified? && rhs.qualified?
+        @package_name == rhs.package_name && @message_name == rhs.message_name
+      else
+        @message_name == rhs.message_name
+      end
+    end
+
+    def hash
+      @message_name.hash
+    end
+  end
+
   # == DESCRIPTION
   # Base class of all messages.
   class Message
     # === DESCRIPTION
-    # Creates a fatal error message from exception object.
+    # Constructs a message.
     #
     # === PARAMETER
-    # _exception_:: Exception -- Cause exception.
-    def self.from_exception(exception)
-      FatalErrorMessage.new(exception)
+    # _msg_tmpl_:: MessageTemplate -- Template for the creating message.
+    # _loc_:: Location -- Location where the message detected.
+    # _parts_:: Array< Object > -- Message formatting parts.
+    def initialize(msg_tmpl, loc, *parts)
+      @template    = msg_tmpl
+      @location    = loc
+      @parts       = parts
+      @complements = []
+    end
+
+    attr_reader :location
+
+    def id
+      @template.message_id
+    end
+
+    def must_be_unique?
+      subclass_responsibility
+    end
+
+    def must_be_deferred?
+      subclass_responsibility
+    end
+
+    def complement_with(msg)
+      @complements.push(msg)
+    end
+
+    def eql?(rhs)
+      id == rhs.id && @location == rhs.location && @parts == rhs.parts
+    end
+
+    def hash
+      [id, @location, @parts].hash
+    end
+
+    def print_as_str(io)
+      io.puts(to_s)
+      @complements.each { |comp| comp.print_as_str(io) }
+    end
+
+    def print_as_csv(io)
+      io.puts(to_csv)
+      @complements.each { |comp| comp.print_as_csv(io) }
     end
 
     # === DESCRIPTION
-    # Constructs a message.
+    # Converts this message into a string for human readable output.
     #
-    # === PARAMETER
-    # _id_:: Symbol -- Message ID symbol.
-    # _location_:: Location -- Location where the message detected.
-    # _parts_:: Array< Object > -- Message formatting parts.
-    def initialize(package, id, location, *parts)
-      @package, @id, @location = package, id, location
-      @parts = parts
-      validate_id(@package, @id, @location)
+    # === RETURN VALUE
+    # String -- String representation of this message.
+    def to_s
+      begin
+        "#{@location.to_s.to_default_external}:" +
+          "#{type_str.to_default_external}:" +
+          "#{id.package_name}:#{id.message_name.to_s}:" +
+          "#{@template.typical_class.category}:" +
+          "#{@template.typical_class.severity}:" +
+          "#{@template.format(@parts)}"
+      rescue
+        raise InvalidMessageFormatError.new(id, @location)
+      end
     end
 
-    attr_reader :id
+    protected
+    attr_reader :parts
 
+    private
     # === DESCRIPTION
     # Reads the type of this message.
     #
@@ -91,97 +167,38 @@ module AdLint #:nodoc:
     # === RETURN VALUE
     # Array< Object > -- Array of message elements.
     def to_a
-      if templ = MessageCatalog.instance.lookup(@package, @id)
-        begin
-          if Traits.instance.of_message.message_with_class
-            [
-              type.to_s,
-              @location.fpath, @location.line_no, @location.column_no,
-              templ.package,
-              @id,
-              templ.typical_class.category,
-              templ.typical_class.severity,
-              templ.format(@parts)
-            ]
-          else
-            [
-              type.to_s,
-              @location.fpath, @location.line_no, @location.column_no,
-              @id,
-              templ.format(@parts)
-            ]
-          end
-        rescue
-          raise InvalidMessageFormatError.new(@package, @id, @location)
-        end
-      else
-        raise InvalidMessageIdError.new(@package, @id, @location)
-      end
-    end
-
-    # === DESCRIPTION
-    # Converts this message into a string for human readable output.
-    #
-    # === RETURN VALUE
-    # String -- String representation of this message.
-    def to_s
-      if templ = MessageCatalog.instance.lookup(@package, @id)
-        begin
-          "#{@location.to_s.to_default_external}:" +
-            "#{type_str.to_default_external}:" +
-            "#{templ.package}:" +
-            "#{@id.to_s.to_default_external}:" +
-            "#{templ.typical_class.category}:" +
-            "#{templ.typical_class.severity}:" +
-            "#{templ.format(@parts)}"
-        rescue
-          raise InvalidMessageFormatError.new(@package, @id, @location)
-        end
-      else
-        raise InvalidMessageIdError.new(@package, @id, @location)
+      begin
+        [
+          type.to_s, *@location.to_a, id.package_name, id.message_name,
+          @template.typical_class.category, @template.typical_class.severity,
+          @template.format(@parts)
+        ]
+      rescue
+        raise InvalidMessageFormatError.new(id, @location)
       end
     end
 
     def to_csv
-      to_a.map { |obj| obj ? obj.to_s.to_default_external : nil }.to_csv
-    end
-
-    def eql?(rhs)
-      @id == rhs.id && @location == rhs.location && @parts == rhs.parts
-    end
-
-    def hash
-      [@id, @location, @parts].hash
-    end
-
-    protected
-    attr_reader :location
-    attr_reader :parts
-
-    private
-    # === DESCRIPTION
-    # Validates the message ID.
-    #
-    # === PARAMETER
-    # _id_:: String -- Message ID string.
-    # _location_:: Location -- Location where the message detected.
-    #
-    # === RETURN VALUE
-    # None.
-    def validate_id(package, id, location)
-      MessageCatalog.instance.lookup(package, id) or
-        raise InvalidMessageIdError.new(package, id, location)
-      nil
+      to_a.map { |obj| obj && obj.to_s.to_default_external }.to_csv
     end
   end
 
   # == DESCRIPTION
   # Syntactical error message.
   class ErrorMessage < Message
-    def initialize(id, location, *parts)
-      super("core", id, location, *parts)
+    def initialize(msg_catalog, msg_name, loc, *parts)
+      super(msg_catalog.lookup(MessageId.new("core", msg_name)), loc, *parts)
+    end
+
+    def must_be_unique?
+      false
     end
 
+    def must_be_deferred?
+      false
+    end
+
+    private
     # === DESCRIPTION
     # Reads the type of this message.
     #
@@ -208,14 +225,24 @@ module AdLint #:nodoc:
     # Constructs a AdLint specific internal fatal error message.
     #
     # === PARAMETER
-    # _exception_:: Exception -- Cause exception.
-    def initialize(exception)
-      super("core", exception.id,
-            exception.location ? exception.location : Location.new,
-            *exception.parts)
-      @exception = exception
+    # _msg_catalog_:: MessageCatalog -- Message catalog.
+    # _cause_ex_:: Exception -- Cause exception.
+    def initialize(msg_catalog, cause_ex)
+      msg_id = MessageId.new("core", cause_ex.message_name)
+      super(msg_catalog.lookup(msg_id), cause_ex.location || Location.new,
+            *cause_ex.parts)
+      @cause_ex = cause_ex
     end
 
+    def must_be_unique?
+      false
+    end
+
+    def must_be_deferred?
+      false
+    end
+
+    private
     # === DESCRIPTION
     # Reads the type of this message.
     #
@@ -238,6 +265,20 @@ module AdLint #:nodoc:
   # == DESCRIPTION
   # Semantical warning message.
   class WarningMessage < Message
+    def initialize(msg_catalog, check_class, loc, *parts)
+      super(msg_catalog.lookup(check_class.message_id), loc, *parts)
+      @check_class = check_class
+    end
+
+    def must_be_unique?
+      @check_class.must_be_unique?
+    end
+
+    def must_be_deferred?
+      @check_class.must_be_deferred?
+    end
+
+    private
     # === DESCRIPTION
     # Reads the type of this message.
     #
@@ -260,6 +301,20 @@ module AdLint #:nodoc:
   # == DESCRIPTION
   # Message complements other messages.
   class ContextMessage < Message
+    def initialize(msg_catalog, msg_name, check_class, loc, *parts)
+      msg_id = MessageId.new(check_class.catalog.name, msg_name)
+      super(msg_catalog.lookup(msg_id), loc, *parts)
+    end
+
+    def must_be_unique?
+      false
+    end
+
+    def must_be_deferred?
+      false
+    end
+
+    private
     # === DESCRIPTION
     # Reads the type of this message.
     #
@@ -281,33 +336,34 @@ module AdLint #:nodoc:
 
   class MessageClass
     def initialize(class_str)
-      @category, @severity = class_str.split(":")
+      @category, @severity =
+        class_str.split(":").map { |str| str.to_default_external }
     end
 
-    def category
-      @category.to_s.to_default_external
-    end
-
-    def severity
-      @severity.to_s.to_default_external
-    end
+    attr_reader :category
+    attr_reader :severity
   end
 
   # == DESCRIPTION
   # Message catalog entry.
   class MessageTemplate
-    def initialize(package, classes, format)
-      @package = package
-      @classes = classes.map { |class_str| MessageClass.new(class_str) }
-      @format = format
-      @typical_class = @classes.sort { |mesg_class| mesg_class.severity }.first
+    def initialize(msg_id, classes, fmt)
+      @message_id    = msg_id
+      @classes       = classes.map { |class_str| MessageClass.new(class_str) }
+      @format        = fmt
+      @typical_class = @classes.sort { |msg_class| msg_class.severity }.first
     end
 
+    attr_reader :message_id
     attr_reader :classes
     attr_reader :typical_class
 
-    def package
-      @package.to_s.to_default_external
+    def categories
+      @classes.map { |c| c.category }
+    end
+
+    def severities
+      @classes.map { |c| c.severity }
     end
 
     def format(parts)
@@ -320,24 +376,23 @@ module AdLint #:nodoc:
     MESSAGES_FNAME = Pathname.new("messages.yml")
     private_constant :MESSAGES_FNAME
 
-    def initialize(package_name)
-      @package_name = package_name
+    def initialize(pkg_name, lang_name)
+      @package_name  = pkg_name
+      @language_name = lang_name
     end
 
-    attr_reader :package_name
-
-    def read_into(message_catalog)
+    def read_into(msg_catalog)
       File.open(fpath, "r:utf-8") do |io|
-        case array_or_stream = YAML.load_stream(io)
+        case ary_or_stream = YAML.load_stream(io)
         when Array
           # NOTE: YAML.load_stream returns Array in Ruby 1.9.3-preview1.
-          doc = array_or_stream.first
+          doc = ary_or_stream.first
         when YAML::Stream
-          doc = array_or_stream.documents.first
+          doc = ary_or_stream.documents.first
         end
         validate_version(doc["version"])
-        if message_definition = doc["message_definition"]
-          message_catalog.merge!(package_name, message_definition)
+        if msg_def = doc["message_definition"]
+          msg_catalog.merge!(@package_name, msg_def)
         else
           raise "invalid form of the message definition file."
         end
@@ -351,11 +406,10 @@ module AdLint #:nodoc:
     end
 
     def fpath
-      lang_dpath = Pathname.new(Traits.instance.of_message.language)
-      base_dpath.join(lang_dpath).join(MESSAGES_FNAME)
+      base_dpath.join(Pathname.new(@language_name)).join(MESSAGES_FNAME)
     end
 
-    def validate_version(version)
+    def validate_version(ver)
       # NOTE: Version field of the message catalog does not mean the schema
       #       version of the catalog file, but a revision number of the catalog
       #       contents.
@@ -366,8 +420,8 @@ module AdLint #:nodoc:
   end
 
   class CoreMessageDefinitionFile < MessageDefinitionFile
-    def initialize
-      super("core")
+    def initialize(lang_name)
+      super("core", lang_name)
     end
 
     private
@@ -377,50 +431,47 @@ module AdLint #:nodoc:
   end
 
   class ExamMessageDefinitionFile < MessageDefinitionFile
-    def initialize(exam_package)
-      super(exam_package.name)
-      @exam_package = exam_package
+    def initialize(exam_pkg, lang_name)
+      super(exam_pkg.name, lang_name)
+      @exam_pkg = exam_pkg
     end
 
     private
     def base_dpath
-      @exam_package.catalog.message_definition_dpath
+      @exam_pkg.catalog.message_definition_dpath
     end
   end
 
   # == DESCRIPTION
   # Message catalog.
   class MessageCatalog
-    include Singleton
-
-    def initialize
+    def initialize(traits)
+      @traits = traits
       @hash = Hash.new
+      message_definition_files.each { |def_file| def_file.read_into(self) }
     end
 
-    def lookup(package_name, mesg_id)
-      @hash[[package_name, mesg_id]]
+    def lookup(msg_id)
+      @hash[msg_id] or raise InvalidMessageIdError.new(msg_id)
     end
 
-    def merge!(package_name, message_definition)
-      message_definition.each do |id, content|
-        message_traits = Traits.instance.of_message
-        if changed = message_traits.change_list[[package_name, id.intern]]
-          content = changed
+    def merge!(pkg_name, msg_def)
+      msg_def.each do |msg_name_str, cont|
+        msg_id = MessageId.new(pkg_name, msg_name_str.to_sym)
+        if changed = @traits.of_message.change_list[msg_id]
+          cont = changed
         end
-        @hash[[package_name, id.intern]] = MessageTemplate.new(
-          package_name, content["classes"], content["format"])
+        @hash[msg_id] =
+          MessageTemplate.new(msg_id, cont["classes"], cont["format"])
       end
     end
 
-    def load
-      message_definition_files.each { |mdef_file| mdef_file.read_into(self) }
-    end
-
     private
     def message_definition_files
-      [CoreMessageDefinitionFile.new] +
-        Traits.instance.exam_packages.map { |exam_package|
-          ExamMessageDefinitionFile.new(exam_package)
+      lang_name = @traits.of_message.language
+      [CoreMessageDefinitionFile.new(lang_name)] +
+        @traits.exam_packages.map { |pkg|
+          ExamMessageDefinitionFile.new(pkg, lang_name)
         }
     end
   end