adlint 2.6.14 → 3.0.0

data/lib/adlint/util.rb

@@ -1,7 +1,7 @@
 # Miscellaneous utilities.
 #
 # 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,9 +29,13 @@
 #
 #++
 
+require "adlint/memo"
+
 module AdLint #:nodoc:
 
   module Validation
+    # NOTE: Host class must respond to #entity_name.
+
     def ensure_validity_of(*args)
       @validators ||= []
       attr_names = _attr_names_in(args)
@@ -52,21 +56,21 @@ module AdLint #:nodoc:
 
     def ensure_numericality_of(*args)
       @validators ||= []
-      attr_names, options = _attr_names_in(args), _options_in(args)
-      only_integer = options[:only_integer] ? true : false
-      min_value = options[:min]
-      max_value = options[:max]
+      attr_names, opts = _attr_names_in(args), _options_in(args)
+      only_int = opts[:only_integer] ? true : false
+      min = opts[:min]
+      max = opts[:max]
       attr_names.each do |attr_name|
-        @validators.push(NumericalityValidator.new(attr_name, only_integer,
-                                                   min_value, max_value))
+        @validators.push(NumericalityValidator.new(attr_name, only_int,
+                                                   min, max))
       end
       self
     end
 
     def ensure_file_presence_of(*args)
       @validators ||= []
-      attr_names, options = _attr_names_in(args), _options_in(args)
-      allow_nil = options[:allow_nil]
+      attr_names, opts = _attr_names_in(args), _options_in(args)
+      allow_nil = opts[:allow_nil]
       attr_names.each do |attr_name|
         @validators.push(FilePresenceValidator.new(attr_name, allow_nil))
       end
@@ -75,8 +79,8 @@ module AdLint #:nodoc:
 
     def ensure_dir_presence_of(*args)
       @validators ||= []
-      attr_names, options = _attr_names_in(args), _options_in(args)
-      allow_nil = options[:allow_nil]
+      attr_names, opts = _attr_names_in(args), _options_in(args)
+      allow_nil = opts[:allow_nil]
       attr_names.each do |attr_name|
         @validators.push(DirPresenceValidator.new(attr_name, allow_nil))
       end
@@ -94,10 +98,10 @@ module AdLint #:nodoc:
 
     def ensure_inclusion_of(*args)
       @validators ||= []
-      attr_names, options = _attr_names_in(args), _options_in(args)
-      values = options[:values] || []
+      attr_names, opts = _attr_names_in(args), _options_in(args)
+      vals = opts[:values] || []
       attr_names.each do |attr_name|
-        @validators.push(InclusionValidator.new(attr_name, values))
+        @validators.push(InclusionValidator.new(attr_name, vals))
       end
       self
     end
@@ -122,11 +126,11 @@ module AdLint #:nodoc:
 
     def ensure_with(*args)
       @validators ||= []
-      attr_names, options = _attr_names_in(args), _options_in(args)
-      message = options[:message] || "is not valid."
-      validator = options[:validator] || lambda { |value| value }
+      attr_names, opts = _attr_names_in(args), _options_in(args)
+      msg = opts[:message] || "is not valid."
+      validator = opts[:validator] || lambda { |val| val }
       attr_names.each do |attr_name|
-        @validators.push(CustomValidator.new(attr_name, message, validator))
+        @validators.push(CustomValidator.new(attr_name, msg, validator))
       end
       self
     end
@@ -135,10 +139,6 @@ module AdLint #:nodoc:
       @validators ||= []
     end
 
-    def name
-      subclass_responsibility
-    end
-
     def valid?
       if self.class.validators
         self.class.validators.map { |validator| validator.execute(self) }.all?
@@ -186,10 +186,10 @@ module AdLint #:nodoc:
       end
 
       def qualified_attr_name(attr_owner)
-        if attr_owner.name.nil? || attr_owner.name.empty?
+        if attr_owner.entity_name.nil? || attr_owner.entity_name.empty?
           @attr_name
         else
-          "#{attr_owner.name}:#{@attr_name}"
+          "#{attr_owner.entity_name}:#{@attr_name}"
         end
       end
     end
@@ -197,9 +197,9 @@ module AdLint #:nodoc:
 
     class ObjectValidator < Validator
       def execute(attr_owner)
-        if object = target_value(attr_owner)
-          return true if object.valid?
-          @errors.concat(object.errors)
+        if obj = target_value(attr_owner)
+          return true if obj.valid?
+          @errors.concat(obj.errors)
         end
         false
       end
@@ -219,32 +219,32 @@ module AdLint #:nodoc:
     private_constant :PresenceValidator
 
     class NumericalityValidator < PresenceValidator
-      def initialize(attr_name, only_integer, min_value, max_value)
+      def initialize(attr_name, only_int, min, max)
         super(attr_name)
-        @only_integer = only_integer
-        @min_value = min_value
-        @max_value = max_value
+        @only_integer = only_int
+        @min = min
+        @max = max
       end
 
       def execute(attr_owner)
         return false unless super
-        value = target_value(attr_owner)
+        val = target_value(attr_owner)
 
-        case value
+        case val
         when Numeric
-          if @only_integer && !value.integer?
+          if @only_integer && !val.integer?
             @errors.push("`#{qualified_attr_name(attr_owner)}' " +
                          "is not an integer.")
             return false
           end
-          if @min_value && value < @min_value
+          if @min && val < @min
             @errors.push("`#{qualified_attr_name(attr_owner)}' " +
-                         "is not greater than or equal to #{@min_value}.")
+                         "is not greater than or equal to #{@min}.")
             return false
           end
-          if @max_value && @max_value < value
+          if @max && @max < val
             @errors.push("`#{qualified_attr_name(attr_owner)}' " +
-                         "is not less than or equal to #{@max_value}.")
+                         "is not less than or equal to #{@max}.")
             return false
           end
         else
@@ -265,18 +265,21 @@ module AdLint #:nodoc:
       end
 
       def execute(attr_owner)
-        value = target_value(attr_owner)
+        val = target_value(attr_owner)
 
-        unless value
-          return true if @allow_nil
-          @errors.push("`#{qualified_attr_name(attr_owner)}' " +
-                       "is not specified.")
-          return false
+        unless val
+          if @allow_nil
+            return true
+          else
+            @errors.push("`#{qualified_attr_name(attr_owner)}' " +
+                         "is not specified.")
+            return false
+          end
         end
 
-        unless File.exist?(value) && File.file?(value)
+        unless File.exist?(val) && File.file?(val)
           @errors.push("`#{qualified_attr_name(attr_owner)}' " +
-                       "is non-existent pathname (#{value.to_s}).")
+                       "is non-existent pathname (#{val.to_s}).")
           return false
         end
         true
@@ -291,18 +294,21 @@ module AdLint #:nodoc:
       end
 
       def execute(attr_owner)
-        value = target_value(attr_owner)
+        val = target_value(attr_owner)
 
-        unless value
-          return true if @allow_nil
-          @errors.push("`#{qualified_attr_name(attr_owner)}' " +
-                       "is not specified.")
-          return false
+        unless val
+          if @allow_nil
+            return true
+          else
+            @errors.push("`#{qualified_attr_name(attr_owner)}' " +
+                         "is not specified.")
+            return false
+          end
         end
 
-        unless File.exist?(value) && File.directory?(value)
+        unless File.exist?(val) && File.directory?(val)
           @errors.push("`#{qualified_attr_name(attr_owner)}' " +
-                       "is non-existent pathname (#{value.to_s}).")
+                       "is non-existent pathname (#{val.to_s}).")
           return false
         end
         true
@@ -312,16 +318,16 @@ module AdLint #:nodoc:
 
     class DirsPresenceValidator < Validator
       def execute(attr_owner)
-        value = target_value(attr_owner)
+        val = target_value(attr_owner)
 
-        bad_paths = value.reject { |pathname|
-          File.exist?(pathname) && File.directory?(pathname)
+        bad_paths = val.reject { |path|
+          File.exist?(path) && File.directory?(path)
         }
 
         unless bad_paths.empty?
-          bad_paths.each do |pathname|
+          bad_paths.each do |path|
             @errors.push("`#{qualified_attr_name(attr_owner)}' " +
-                         "contains non-existent pathname (#{pathname.to_s}).")
+                         "contains non-existent pathname (#{path.to_s}).")
           end
           return false
         end
@@ -331,16 +337,16 @@ module AdLint #:nodoc:
     private_constant :DirsPresenceValidator
 
     class InclusionValidator < PresenceValidator
-      def initialize(attr_name, values)
+      def initialize(attr_name, vals)
         super(attr_name)
-        @values = values
+        @values = vals
       end
 
       def execute(attr_owner)
         return false unless super
-        value = target_value(attr_owner)
+        val = target_value(attr_owner)
 
-        unless @values.include?(value)
+        unless @values.include?(val)
           @errors.push("`#{qualified_attr_name(attr_owner)}' " +
                        "is not one of #{@values.join(", ")}.")
           return false
@@ -367,21 +373,21 @@ module AdLint #:nodoc:
 
     class ExamPackagesPresenceValidator < Validator
       def execute(attr_owner)
-        value = target_value(attr_owner)
+        val = target_value(attr_owner)
 
-        if value.empty?
+        if val.empty?
           @errors.push("`#{qualified_attr_name(attr_owner)}' " +
                        "is not specified.")
           return false
         end
 
-        bad_exams = value.reject { |exam_package| exam_package.load }
+        bad_exams = val.reject { |exam_pkg| exam_pkg.load }
 
         unless bad_exams.empty?
-          bad_exams.each do |exam_package|
+          bad_exams.each do |exam_pkg|
             @errors.push("`#{qualified_attr_name(attr_owner)}' " +
                          "contains non-existent exam-package name " +
-                         "(#{exam_package.name}).")
+                         "(#{exam_pkg.name}).")
           end
           return false
         end
@@ -391,9 +397,9 @@ module AdLint #:nodoc:
     private_constant :ExamPackagesPresenceValidator
 
     class CustomValidator < Validator
-      def initialize(attr_name, message, validator)
+      def initialize(attr_name, msg, validator)
         super(attr_name)
-        @message = message
+        @message = msg
         @validator = validator
       end
 
@@ -415,134 +421,21 @@ module AdLint #:nodoc:
 
     private
     def visitor_method_name
-      unless defined?(@visitor_method_name)
-        node_name = self.class.name.sub(/\A.*::/, "")
-        node_name = node_name.gsub(/([A-Z][a-z])/, "_\\1")
-        node_name = node_name.sub(/\A_/, "").tr("A-Z", "a-z")
-        @visitor_method_name = "visit_#{node_name}".intern
-      end
-      @visitor_method_name
+      node_name = self.class.name.sub(/\A.*::/, "")
+      node_name = node_name.gsub(/([A-Z][a-z])/, "_\\1")
+      node_name = node_name.sub(/\A_/, "").tr("A-Z", "a-z")
+      "visit_#{node_name}".to_sym
     end
+    memoize :visitor_method_name
   end
 
   class CsvRecord
-    def initialize(array)
-      @array = array
-    end
-
-    def field_at(index)
-      @array.fetch(index)
-    end
-  end
-
-  module Memoizable
-    def memoize(name, *key_indices)
-      orig_name = "_orig_#{name}"
-      class_eval <<-EOS
-        alias_method("#{orig_name}", "#{name}")
-        private("#{orig_name}")
-      EOS
-      if key_indices.empty?
-        if instance_method("#{name}").arity == 0
-          define_cache_manipulator(name)
-          class_eval <<-EOS
-            define_method("#{name}") do |*args|
-              @_#{name}_cache ||= nil
-              @_#{name}_cache_forbidden ||= false
-              if result = @_#{name}_cache
-                @_#{name}_cache_forbidden = false
-              else
-                result = #{orig_name}(*args)
-                if @_#{name}_cache_forbidden
-                  @_#{name}_cache_forbidden = false
-                else
-                  @_#{name}_cache = result
-                end
-              end
-              result
-            end
-          EOS
-        else
-          define_cache_manipulator(name, key_indices)
-          class_eval <<-EOS
-            define_method("#{name}") do |*args|
-              @_#{name}_cache ||= {}
-              @_#{name}_cache_forbidden ||= false
-              if result = @_#{name}_cache[args]
-                @_#{name}_cache_forbidden = false
-              else
-                result = #{orig_name}(*args)
-                if @_#{name}_cache_forbidden
-                  @_#{name}_cache_forbidden = false
-                else
-                  @_#{name}_cache[args] = result
-                end
-              end
-              result
-            end
-          EOS
-        end
-      else
-        define_cache_manipulator(name, key_indices)
-        class_eval <<-EOS
-          define_method("#{name}") do |*args|
-            @_#{name}_cache ||= {}
-            @_#{name}_cache_forbidden ||= false
-            key = args.values_at(#{key_indices.join(',')})
-            if result = @_#{name}_cache[key]
-              @_#{name}_cache_forbidden = false
-            else
-              result = #{orig_name}(*args)
-              if @_#{name}_cache_forbidden
-                @_#{name}_cache_forbidden = false
-              else
-                @_#{name}_cache[key] = result
-              end
-            end
-            result
-          end
-        EOS
-      end
+    def initialize(ary)
+      @ary = ary
     end
 
-    private
-    def define_cache_manipulator(name, key_indices = nil)
-      class_eval <<-EOS
-        define_method("forbid_#{name}_memoizing_once") do |*args|
-          @_#{name}_cache_forbidden = true
-        end
-      EOS
-      case
-      when key_indices && key_indices.empty?
-        class_eval <<-EOS
-          define_method("forget_#{name}_memo") do |*args|
-            @_#{name}_cache.delete(args) if defined?(@_#{name}_cache)
-          end
-          define_method("clear_#{name}_memo") do |*args|
-            @_#{name}_cache.clear if defined?(@_#{name}_cache)
-          end
-        EOS
-      when key_indices
-        class_eval <<-EOS
-          define_method("forget_#{name}_memo") do |*args|
-            if defined?(@_#{name}_cache)
-              @_#{name}_cache.delete(args.values_at(#{key_indices.join(',')}))
-            end
-          end
-          define_method("clear_#{name}_memo") do |*args|
-            @_#{name}_cache.clear if defined?(@_#{name}_cache)
-          end
-        EOS
-      else
-        class_eval <<-EOS
-          define_method("forget_#{name}_memo") do |*args|
-            @_#{name}_cache = nil
-          end
-          define_method("clear_#{name}_memo") do |*args|
-            @_#{name}_cache = nil
-          end
-        EOS
-      end
+    def field_at(idx)
+      @ary.fetch(idx)
     end
   end
 
@@ -573,17 +466,6 @@ module AdLint #:nodoc:
     end
   end
 
-  module PackageResolver
-    def package_name_of(class_or_module)
-      if class_or_module.name =~ /\AAdLint::Exam::(.*?)::/
-        $1.sub(/\A./) { |s| s.downcase }.gsub(/[A-Z]/) { |s| "_#{s.downcase}" }
-      else
-        "core"
-      end
-    end
-    module_function :package_name_of
-  end
-
   module CompoundPathParser
     def parse_compound_path_list(ary)
       (ary || []).compact.map { |str| parse_compound_path_str(str) }.flatten
@@ -596,6 +478,35 @@ module AdLint #:nodoc:
     module_function :parse_compound_path_str
   end
 
+  module LogUtil
+    # NOTE: Host class must respond to #logger.
+
+    def log_fatal(*args, &block)
+      logger.fatal(*args, &block)
+    end
+    alias :LOG_F :log_fatal
+
+    def log_error(*args, &block)
+      logger.error(*args, &block)
+    end
+    alias :LOG_E :log_error
+
+    def log_warn(*args, &block)
+      logger.warn(*args, &block)
+    end
+    alias :LOG_W :log_warn
+
+    def log_info(*args, &block)
+      logger.info(*args, &block)
+    end
+    alias :LOG_I :log_info
+
+    def log_debug(*args, &block)
+      logger.debug(*args, &block)
+    end
+    alias :LOG_D :log_debug
+  end
+
 end
 
 if $0 == __FILE__
@@ -606,7 +517,7 @@ if $0 == __FILE__
       p "foo"
     end
 
-    extend AdLint::Pluggable
+    extend ::AdLint::Pluggable
 
     def_plugin :on_initialization