adlint 2.6.14 → 3.0.0

data/lib/adlint/monitor.rb

@@ -1,7 +1,7 @@
 # Progress monitoring mechanism.
 #
 # 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.
 #
@@ -36,56 +36,55 @@ require "adlint/report"
 module AdLint #:nodoc:
 
   module MonitorUtil
+    # NOTE: Host class must respond to #monitor.
+
     def monitored_region(title, total = 1)
-      ProgressMonitor.instance.start(title, total)
-      result = yield(ProgressMonitor.instance)
-      ProgressMonitor.instance.finish
-      result
+      monitor.start(title, total)
+      retval = yield(monitor)
+      monitor.finish
+      retval
     rescue Error
-      ProgressMonitor.instance.abort
+      monitor.abort
       raise
     rescue => ex
-      ProgressMonitor.instance.abort
-      raise InternalError.new(ex, ProgressMonitor.instance.location)
+      monitor.abort
+      raise InternalError.new(ex, monitor.location)
     end
-    module_function :monitored_region
 
-    def checkpoint(location_or_numeric)
-      case location_or_numeric
+    def checkpoint(loc_or_num)
+      case loc_or_num
       when Location
-        ProgressMonitor.instance.location = location_or_numeric
+        monitor.location = loc_or_num
       when Numeric
-        ProgressMonitor.instance.progress = location_or_numeric
+        monitor.progress = loc_or_num
       end
     end
-    module_function :checkpoint
   end
 
   class ProgressMonitor
-    include Singleton
+    def initialize(fpath, phase_num, verbose)
+      @fpath      = fpath
+      @phase_num  = phase_num
+      @verbose    = verbose
+      @start_time = Time.now
+      @cur_phase  = 0
+    end
 
     attr_reader :location
     attr_reader :progress
 
-    def reset(fpath, phase_num)
-      @fpath = fpath
-      @phase_num = phase_num
-      @current_phase = 0
-      @start_time = Time.now
-    end
-
     def start(title, total = 1)
-      @total = total
-      @title = title
+      @total    = total
+      @title    = title
       @location = nil
       @progress = 0
-      @current_phase += 1
+      @cur_phase += 1
       draw
     end
 
     def finish
       @progress = @total
-      if @current_phase == @phase_num
+      if @cur_phase == @phase_num
         draw_finished
       else
         draw
@@ -96,39 +95,42 @@ module AdLint #:nodoc:
       draw_aborted
     end
 
-    def location=(location)
-      @location = location
-      if false && File.identical?(location.fpath, @fpath)
-        self.progress = location.line_no
+    def location=(loc)
+      @location = loc
+      if false && @fpath.identical?(@location.fpath)
+        self.progress = @location.line_no
       end
     end
 
-    def progress=(value)
-      @progress = value
+    def progress=(val)
+      @progress = val
       draw
     end
 
     private
     def draw
-      return unless verbose?
-      draw_bar(@fpath, @title)
-      print " %3d%%" % (total_progress * 100).to_i
+      if @verbose
+        draw_bar(@fpath, @title)
+        print " %3d%%" % (total_progress * 100).to_i
+      end
     end
 
     def draw_finished
-      return unless verbose?
-      draw_bar(@fpath, "fin")
-      puts " %.3fs" % (Time.now - @start_time)
+      if @verbose
+        draw_bar(@fpath, "fin")
+        puts " %.3fs" % (Time.now - @start_time)
+      end
     end
 
     def draw_aborted
-      return unless verbose?
-      draw_bar(@fpath, @title)
-      puts " %.3fs!" % (Time.now - @start_time)
+      if @verbose
+        draw_bar(@fpath, @title)
+        puts " %.3fs!" % (Time.now - @start_time)
+      end
     end
 
     def total_progress
-      phase_start = (@current_phase - 1).to_f / @phase_num
+      phase_start    = (@cur_phase - 1).to_f / @phase_num
       phase_progress = @progress.to_f / @total / @phase_num
       phase_start + phase_progress
     end

data/lib/adlint/phase.rb

@@ -1,7 +1,7 @@
 # Base of analysis phase classes.
 #
 # 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.
 #
@@ -44,22 +44,22 @@ module AdLint #:nodoc:
     # Constructs an analysis pass.
     #
     # === PARAMETER
-    # _context_:: PhaseContext -- Analysis context.
-    def initialize(context, package_name, phase_name)
-      @context = context
-      @package_name = package_name
+    # _phase_ctxt_:: PhaseContext -- Analysis context.
+    def initialize(phase_ctxt, pkg_name, phase_name)
+      @phase_ctxt = phase_ctxt
+      @pkg_name   = pkg_name
       @phase_name = phase_name
     end
 
     # === DESCRIPTION
     # Executes the analysis.
     def execute
-      monitored_region(@phase_name) do |monitor|
-        do_execute(@context, monitor)
-        register_examinations
+      monitored_region(@phase_name) do |mon|
+        do_execute(@phase_ctxt, mon)
+        register_examinations(@phase_ctxt)
       end
     rescue Error => ex
-      @context.report.add_message(Message.from_exception(ex))
+      report.write_message(FatalErrorMessage.new(message_catalog, ex))
       raise
     end
 
@@ -68,47 +68,74 @@ module AdLint #:nodoc:
     # Executes the analysis.
     #
     # Subclasses must implement this method.
-    def do_execute(context, monitor)
+    def do_execute(phase_ctxt, monitor)
       subclass_responsibility
     end
 
-    def register_examinations
-      context_key = context_key_of("examinations")
-      @context[context_key] ||= []
-      Traits.instance.exam_packages.each do |exam_package|
-        exam_package.catalog.examination_classes.each do |exam_class|
-          if exam_class.registrant_phase_class == self.class
-            @context[context_key].push(exam_class.new(@context))
+    def register_examinations(phase_ctxt)
+      key = context_key_of("examinations")
+      phase_ctxt[key] ||= []
+      traits.exam_packages.each do |exam_pkg|
+        exam_pkg.catalog.examination_classes.each do |exam_class|
+          next unless exam_class.registrant_phase_class == self.class
+          if exam_class.required?(phase_ctxt)
+            phase_ctxt[key].push(exam_class.new(phase_ctxt))
           end
         end
       end
     end
 
     def examinations
-      @context[context_key_of("examinations")] || []
+      @phase_ctxt[context_key_of("examinations")] || []
     end
 
     def context_key_of(str)
-      "#{@package_name}_#{str}".intern
+      "#{@pkg_name}_#{str}".to_sym
     end
+
+    extend Forwardable
+
+    def_delegator :@phase_ctxt, :traits
+    private :traits
+
+    def_delegator :@phase_ctxt, :report
+    private :report
+
+    def_delegator :@phase_ctxt, :message_catalog
+    private :message_catalog
+
+    def_delegator :@phase_ctxt, :monitor
+    private :monitor
+
+    def_delegator :@phase_ctxt, :logger
+    private :logger
   end
 
   class PhaseContext < Hash
-    def initialize(report, log_fpath)
+    def initialize(analyzer, report, monitor)
       super()
-      @report = report
-      @log_fpath = log_fpath
+      @analyzer = analyzer
+      @report   = report
+      @monitor  = monitor
     end
 
     attr_reader :report
-    attr_reader :log_fpath
+    attr_reader :monitor
 
-    def msg_fpath
-      @report.msg_fpath
-    end
+    extend Forwardable
+
+    def_delegator :@analyzer, :traits
+    def_delegator :@analyzer, :message_catalog
+    def_delegator :@analyzer, :logger
 
-    def met_fpath
-      @report.met_fpath
+    def_delegator :@report, :msg_fpath
+    def_delegator :@report, :met_fpath
+    def_delegator :@report, :log_fpath
+
+    def flush_deferred_report!
+      if supps = self[:suppressors]
+        @report.flush_deferred_messages(supps)
+      end
     end
   end
 

data/lib/adlint/prelude.rb

@@ -1,7 +1,7 @@
 # Global ruby extensions preloaded before execution.
 #
 # 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,6 +29,8 @@
 #
 #++
 
+require "adlint/memo"
+
 module Kernel
   private
   def subclass_responsibility
@@ -40,32 +42,20 @@ module Kernel
     raise "NOTREACHED"
   end
   module_function :__NOTREACHED__
-
-  def print_elapsed_time(io)
-    tms = Process.times
-    io.print "  %.3fs user, %.3fs system, " % [tms.utime, tms.stime]
-    total = tms.utime + tms.stime
-    h = total / 3600
-    m = total / 60 % 60
-    s = (total % 60).floor
-    io.puts "%02d:%02d:%02d.%02d total" % [h, m, s, ((total % 60) - s) * 100]
-  end
-
-  def verbose=(verbose)
-    # NOTE: The meaning of this verbose flag is not same as one of $VERBOSE.
-    @@verbose = verbose
-  end
-
-  def verbose?
-    @@verbose
-  end
 end
 
 class Module
+  include ::AdLint::Memoizable
+
   # NOTE: Module.private_constant is added in Ruby 1.9.3-p0.
   unless public_instance_methods.include?(:private_constant)
     def private_constant(*) end
   end
+
+  def outer_module
+    eval self.name.sub(/(.*)::.*\z/, "\\1")
+  end
+  memoize :outer_module
 end
 
 class Encoding
@@ -94,9 +84,9 @@ class LazyInstantiation
 
   undef_method(*(Object.new.public_methods - [:__id__, :object_id, :__send__]))
 
-  def method_missing(id, *args)
+  def method_missing(name, *args)
     @receiver ||= @klass.new(*@args, &@block)
-    @receiver.__send__(id, *args)
+    @receiver.__send__(name, *args)
   end
 end
 
@@ -130,19 +120,46 @@ class Pathname
   def components
     self.each_filename.to_a
   end
+  memoize :components
+
+  def real_components
+    self.realpath.each_filename.to_a
+  end
+  memoize :real_components
+
+  memoize :realpath
+  memoize :cleanpath
 
   def strip(num = 0)
     comps = self.components
-    if num >= 0 && num < comps.size
-      comps = comps.slice(num..-1)
-    end
-
+    comps = comps.slice(num..-1) if num >= 0 && num < comps.size
     Pathname.new(comps.reduce { |stripped, comp| File.join(stripped, comp) })
   end
 
   def add_ext(ext_str)
     Pathname.new(self.to_s + ext_str)
   end
+
+  def identical?(rhs)
+    case rhs
+    when Pathname
+      self.cleanpath == rhs.cleanpath
+    when String
+      self.cleanpath == Pathname.new(rhs).cleanpath
+    else
+      false
+    end
+  end
+  memoize :identical?
+
+  def under?(parent_dpath)
+    lhs_comps, rhs_comps = self.real_components, parent_dpath.real_components
+    if rhs_comps.size < lhs_comps.size
+      rhs_comps.zip(lhs_comps).all? { |rhs, lhs| lhs == rhs }
+    else
+      false
+    end
+  end
 end
 
 class String
@@ -165,8 +182,8 @@ class String
 end
 
 class Substring < String
-  def initialize(str, index, length)
-    @range = index...(index + length)
+  def initialize(str, idx, len)
+    @range = idx...(idx + len)
     super(str.slice(@range))
   end
 
@@ -174,8 +191,8 @@ class Substring < String
 end
 
 class SubstringPair < Array
-  def initialize(lhs_suffix, rhs_suffix, length)
-    super([lhs_suffix.prefix(length), rhs_suffix.prefix(length)])
+  def initialize(lhs_suffix, rhs_suffix, len)
+    super([lhs_suffix.prefix(len), rhs_suffix.prefix(len)])
   end
 
   def lhs
@@ -191,12 +208,12 @@ class Suffix
   include Comparable
 
   def self.of(str)
-    str.length.times.map { |index| new(str, index) }
+    str.length.times.map { |idx| new(str, idx) }
   end
 
-  def initialize(owner, index)
+  def initialize(owner, idx)
     @owner = owner
-    @index = index
+    @index = idx
   end
   private_class_method :new
 
@@ -216,8 +233,8 @@ class Suffix
     to_s.chars.zip(rhs.to_s.chars).take_while { |lch, rch| lch == rch }.size
   end
 
-  def prefix(length)
-    Substring.new(@owner, @index, length)
+  def prefix(len)
+    Substring.new(@owner, @index, len)
   end
 
   def <=>(rhs)
@@ -251,13 +268,12 @@ class SuffixArray < Array
   end
 
   def longest_common_substrings
-    length = self.longest_common_prefix_length
+    len = self.longest_common_prefix_length
 
-    return [] if length == 0
+    return [] if len == 0
 
-    self.each_index.reduce([]) { |result, index|
-      self[index][1] == length ?
-        result + create_substring_pairs(index, length) : result
+    self.each_index.reduce([]) { |result, idx|
+      self[idx][1] == len ? result + create_substring_pairs(idx, len) : result
     }
   end
 
@@ -267,31 +283,27 @@ class SuffixArray < Array
 
   private
   def update_height_of_each_suffixes!
-    (1...self.size).each do |index|
-      self[index][1] = self[index - 1][0].common_prefix_length(self[index][0])
+    (1...self.size).each do |idx|
+      self[idx][1] = self[idx - 1][0].common_prefix_length(self[idx][0])
     end
   end
 
-  def create_substring_pairs(index, length)
-    base_suffix = self[index][0]
+  def create_substring_pairs(idx, len)
+    base_suffix = self[idx][0]
 
     if base_suffix.lhs?
-      create_entry = lambda { |lhs, rhs, len|
-        SubstringPair.new(lhs, rhs, len)
-      }
+      create_entry = lambda { |lhs, rhs, l| SubstringPair.new(lhs, rhs, l) }
     else
-      create_entry = lambda { |rhs, lhs, len|
-        SubstringPair.new(lhs, rhs, len)
-      }
+      create_entry = lambda { |rhs, lhs, l| SubstringPair.new(lhs, rhs, l) }
     end
 
     result = []
 
-    (0...index).reverse_each do |i|
-      break unless self[i + 1][1] == length
+    (0...idx).reverse_each do |i|
+      break unless self[i + 1][1] == len
 
       unless base_suffix.same_owner?(self[i][0])
-        result.push(create_entry[base_suffix, self[i][0], length])
+        result.push(create_entry[base_suffix, self[i][0], len])
       end
     end