anodator 1.0.0.pre1 → 1.0.0.pre2

data/lib/anodator/input_spec_item.rb

@@ -1,20 +1,20 @@
 module Anodator
   class InputSpecItem
-    TYPE_STRING  = "STRING"
-    TYPE_NUMERIC = "NUMERIC"
-    TYPE_DATE    = "DATE"
+    TYPE_STRING  = 'STRING'.freeze
+    TYPE_NUMERIC = 'NUMERIC'.freeze
+    TYPE_DATE    = 'DATE'.freeze
 
     attr_reader :number, :name, :type
 
     def initialize(number, name, type = TYPE_STRING)
       if number.nil? || number.to_s.split(//).size.zero?
-        raise ArgumentError.new("number cannot be blank")
+        raise ArgumentError, 'number cannot be blank'
       end
       if name.nil? || name.to_s.split(//).size.zero?
-        raise ArgumentError.new("name cannot be blank")
+        raise ArgumentError, 'name cannot be blank'
       end
       unless [TYPE_STRING, TYPE_NUMERIC, TYPE_DATE].include?(type)
-        raise ArgumentError.new("unknown data type '#{type}'")
+        raise ArgumentError, "unknown data type '#{type}'"
       end
 
       @number = number
@@ -24,9 +24,9 @@ module Anodator
 
     def ==(other)
       if other.is_a? InputSpecItem
-        self.number == other.number
+        number == other.number
       else
-        return false
+        false
       end
     end
   end

data/lib/anodator/message.rb

@@ -1,7 +1,7 @@
-require "anodator/anodator_error"
+require 'anodator/anodator_error'
 
 module Anodator
-  class UnknownMessageAttributeError < AnodatorError ; end
+  class UnknownMessageAttributeError < AnodatorError; end
 
   # Message is error message builder.
   #
@@ -15,7 +15,7 @@ module Anodator
       @template = template_message.to_s
 
       if @template.split(//).size.zero?
-        raise ArgumentError.new("template_message cannot be blank")
+        raise ArgumentError, 'template_message cannot be blank'
       end
     end
 
@@ -31,29 +31,29 @@ module Anodator
     #   - value:  target actual data
     def expand(data_provider)
       @template.gsub(/\[\[([^:]+)::([^\]]+)\]\]/) do
-        spec_item = data_provider.spec_item_by_expression($1)
-        case $2
-        when "name"
+        spec_item = data_provider.spec_item_by_expression(Regexp.last_match(1))
+        case Regexp.last_match(2)
+        when 'name'
           spec_item.name
-        when "number"
+        when 'number'
           spec_item.number
-        when "value"
-          data_provider[$1]
+        when 'value'
+          data_provider[Regexp.last_match(1)]
         else
-          raise UnknownMessageAttributeError.new("Unknown message attribute '#{$2}'")
+          raise UnknownMessageAttributeError, "Unknown message attribute '#{Regexp.last_match(2)}'"
         end
       end
     end
 
     def validate_configuration
       @template.gsub(/\[\[([^:]+)::([^\]]+)\]\]/) do
-        Validator::Base.values.spec_item_by_expression($1)
-        unless %W(name number value).include?($2)
-          raise UnknownMessageAttributeError.new("Unknown message attribute '#{$2}'")
+        Validator::Base.values.spec_item_by_expression(Regexp.last_match(1))
+        unless %w[name number value].include?(Regexp.last_match(2))
+          raise UnknownMessageAttributeError, "Unknown message attribute '#{Regexp.last_match(2)}'"
         end
       end
     rescue UnknownTargetExpressionError, UnknownMessageAttributeError => e
-      raise InvalidConfiguration.new(e.to_s)
+      raise InvalidConfiguration, e.to_s
     end
   end
 end

data/lib/anodator/output_spec.rb

@@ -1,28 +1,28 @@
 module Anodator
   class OutputSpec
-    TARGET_DATA  = "DATA"
-    TARGET_ERROR = "ERROR"
+    TARGET_DATA  = 'DATA'.freeze
+    TARGET_ERROR = 'ERROR'.freeze
 
-    VALID_SYMBOL_ITEMS = [
-                          :target_numbers,
-                          :target_names,
-                          :target_values,
-                          :error_message,
-                          :error_level,
-                          :error_count,
-                          :warning_count,
-                          :error_and_warning_count,
-                         ]
+    VALID_SYMBOL_ITEMS = %i[
+      target_numbers
+      target_names
+      target_values
+      error_message
+      error_level
+      error_count
+      warning_count
+      error_and_warning_count
+    ].freeze
 
     attr_reader   :items, :target, :include_no_error
     attr_accessor :separator, :value_separator
 
-    def initialize(items = [], options = { })
+    def initialize(items = [], options = {})
       @items            = items.to_a
       @target           = TARGET_ERROR
       @include_no_error = false
-      @separator        = " "
-      @value_separator  = ""
+      @separator        = ' '
+      @value_separator  = ''
 
       options.each do |key, opt|
         case key
@@ -33,12 +33,12 @@ module Anodator
         when :separator, :value_separator
           @separator = opt.to_s
         else
-          raise ArgumentError.new("unknown option #{key}.")
+          raise ArgumentError, "unknown option #{key}."
         end
       end
 
       unless [TARGET_DATA, TARGET_ERROR].include?(@target)
-        raise ArgumentError.new("unknown target option value #{@target}.")
+        raise ArgumentError, "unknown target option value #{@target}."
       end
 
       check_items
@@ -46,20 +46,17 @@ module Anodator
 
     def validate_configuration
       @items.each do |item|
-        if item.is_a? String
-          Validator::Base.values.spec_item_at_by_number(item)
-        end
+        Validator::Base.values.spec_item_at_by_number(item) if item.is_a? String
       end
     rescue UnknownTargetExpressionError => e
-      raise InvalidConfiguration.new(e.to_s)
+      raise InvalidConfiguration, e.to_s
     end
 
     def check_items
       @items.each do |item|
-        if item.is_a? Symbol
-          unless VALID_SYMBOL_ITEMS.include?(item)
-            raise ArgumentError.new("unknown item symbol #{item}")
-          end
+        next unless item.is_a? Symbol
+        unless VALID_SYMBOL_ITEMS.include?(item)
+          raise ArgumentError, "unknown item symbol #{item}"
         end
       end
     end
@@ -79,24 +76,24 @@ module Anodator
         if item.is_a? Symbol
           case item
           when :error_count
-            next check_results.map { |result|
+            next check_results.map do |result|
               result.error? ? true : nil
-            }.compact.size.to_s
+            end.compact.size.to_s
           when :warning_count
-            next check_results.map { |result|
+            next check_results.map do |result|
               result.warning? ? true : nil
-            }.compact.size.to_s
+            end.compact.size.to_s
           when :error_and_warning_count
             next check_results.size.to_s
           else
-            next ""
+            next ''
           end
         else # data
           next input_spec_with_values[item]
         end
       end
 
-      return buf
+      buf
     end
     private :generate_data
 
@@ -109,9 +106,9 @@ module Anodator
             if item.is_a? Symbol
               case item
               when :error_count, :warning_count, :error_and_warning_count
-                next "0"
+                next '0'
               else
-                next ""
+                next ''
               end
             else # data
               next input_spec_with_values[item]
@@ -126,29 +123,29 @@ module Anodator
               when :target_numbers
                 next check_result.target_numbers.join(@separator)
               when :target_names
-                next check_result.target_numbers.map { |number|
+                next check_result.target_numbers.map do |number|
                   input_spec_with_values.spec_item_at_by_number(number).name
-                }.join(@separator)
+                end.join(@separator)
               when :target_values
-                next check_result.target_numbers.map { |number|
+                next check_result.target_numbers.map do |number|
                   input_spec_with_values[number]
-                }.join(@value_separator)
+                end.join(@value_separator)
               when :error_message
                 next check_result.message
               when :error_level
                 next check_result.level.to_s
               when :error_count
-                next check_results.map { |result|
+                next check_results.map do |result|
                   result.error? ? true : nil
-                }.compact.size.to_s
+                end.compact.size.to_s
               when :warning_count
-                next check_results.map { |result|
+                next check_results.map do |result|
                   result.warning? ? true : nil
-                }.compact.size.to_s
+                end.compact.size.to_s
               when :error_and_warning_count
                 next check_results.size.to_s
               else
-                next ""
+                next ''
               end
             else # data
               next input_spec_with_values[item]
@@ -157,7 +154,7 @@ module Anodator
         end
       end
 
-      return buf
+      buf
     end
     private :generate_error
   end

data/lib/anodator/rule.rb

@@ -1,6 +1,6 @@
-require "anodator/message"
-require "anodator/validator"
-require "anodator/check_result"
+require 'anodator/message'
+require 'anodator/validator'
+require 'anodator/check_result'
 
 module Anodator
   # Check rule
@@ -13,30 +13,30 @@ module Anodator
     # default levels are error and warning.
     # You can add any levels.
     ERROR_LEVELS = {
-      :error   => 2, # ERROR
-      :warning => 1, # WARNING
+      error: 2, # ERROR
+      warning: 1, # WARNING
     }
 
     # Check level names
     #
     # Check level name labels
     ERROR_LEVEL_NAMES = {
-      :error   => "ERROR",
-      :warning => "WARNING",
+      error: 'ERROR',
+      warning: 'WARNING'
     }
 
     attr_reader :target_expressions, :message, :validator, :prerequisite, :level, :description
 
     def self.add_error_level(value, symbol, label)
       # value check
-      raise "Error level value must be Integer" unless value.is_a? Integer
-      raise "Error level value must be greater than zero" unless value > 0
+      raise 'Error level value must be Integer' unless value.is_a? Integer
+      raise 'Error level value must be greater than zero' unless value > 0
       raise "Error level value #{value} already exists" if ERROR_LEVELS.values.include?(value)
       # symbol check
-      raise "Error level symbol must be symbol" unless symbol.is_a? Symbol
+      raise 'Error level symbol must be symbol' unless symbol.is_a? Symbol
       raise "Error level symbol #{symbol} already exists" if ERROR_LEVELS.keys.include?(symbol)
       # label check
-      raise "Error level label must be string" unless label.is_a? String
+      raise 'Error level label must be string' unless label.is_a? String
       raise "Error level label #{label} already exists" if ERROR_LEVEL_NAMES.values.include?(label)
 
       # check OK
@@ -48,7 +48,7 @@ module Anodator
       # symbol check
       raise "Unknown rror level symbol #{symbol}" unless ERROR_LEVELS.keys.include?(symbol)
       # count check
-      raise "Error levels must be atleast one value" if ERROR_LEVELS.size == 1
+      raise 'Error levels must be atleast one value' if ERROR_LEVELS.size == 1
 
       # check OK
       ERROR_LEVELS.delete(symbol)
@@ -64,19 +64,15 @@ module Anodator
       @description        = description
 
       if @target_expressions.size.zero?
-        raise ArgumentError.new("target expressions cannot be blank")
-      end
-      if @message.nil?
-        raise ArgumentError.new("message cannot be blank")
-      end
-      if @validator.nil?
-        raise ArgumentError.new("validator cannot be blank")
+        raise ArgumentError, 'target expressions cannot be blank'
       end
+      raise ArgumentError, 'message cannot be blank' if @message.nil?
+      raise ArgumentError, 'validator cannot be blank' if @validator.nil?
       unless ERROR_LEVELS.values.include?(@level)
-        raise ArgumentError.new("level must be #{ERROR_LEVEL_NAMES.join(", ")}.")
+        raise ArgumentError, "level must be #{ERROR_LEVEL_NAMES.join(', ')}."
       end
       if @prerequisite.is_a? Array
-        @prerequisite = Validator::ComplexValidator.new(:validators => @prerequisite)
+        @prerequisite = Validator::ComplexValidator.new(validators: @prerequisite)
       end
     end
 
@@ -86,9 +82,7 @@ module Anodator
     # return nil.
     def check
       unless @prerequisite.nil?
-        unless @prerequisite.valid?
-          return nil
-        end
+        return nil unless @prerequisite.valid?
       end
 
       if @validator.valid?
@@ -112,11 +106,11 @@ module Anodator
       @validator.validate_configuration
       @prerequisite.validate_configuration unless @prerequisite.nil?
     rescue UnknownTargetExpressionError => e
-      raise InvalidConfiguration.new(e.to_s)
+      raise InvalidConfiguration, e.to_s
     end
 
     def level_expression
-      return Rule.level_expression(@level)
+      Rule.level_expression(@level)
     end
 
     def self.level_expression(level)
@@ -124,20 +118,20 @@ module Anodator
         return ERROR_LEVEL_NAMES[ERROR_LEVELS.key(level)]
       end
 
-      return nil
+      nil
     end
 
     def to_s
-      target_names = @target_expressions.map { |te| Validator::Base.values.spec_item_by_expression(te).name }.join(",")
-      buf =<<_EOD_
-Description: #{@description.nil? ? "None." : @description}
+      target_names = @target_expressions.map { |te| Validator::Base.values.spec_item_by_expression(te).name }.join(',')
+      buf = <<_EOD_
+Description: #{@description.nil? ? 'None.' : @description}
   Targets: #{target_names}
   Message: #{@message.template}
   Level: #{level_expression}
   Validator:
-#{@validator.to_s}
+#{@validator}
   Prerequisite:
-#{@prerequisite.nil? ? "    - (None)" : @prerequisite.to_s}
+#{@prerequisite.nil? ? '    - (None)' : @prerequisite.to_s}
 _EOD_
     end
   end

data/lib/anodator/rule_set.rb

@@ -1,4 +1,4 @@
-require "anodator/rule"
+require 'anodator/rule'
 
 module Anodator
   class RuleSet
@@ -11,11 +11,11 @@ module Anodator
       if rule.is_a? Rule
         @rules << rule
       else
-        raise ArgumentError.new("rule must be Anodator::Rule object")
+        raise ArgumentError, 'rule must be Anodator::Rule object'
       end
     end
 
-    alias_method :<<, :add_rule
+    alias << add_rule
 
     def check_all
       @results = []
@@ -33,20 +33,14 @@ module Anodator
       end
     end
 
-    def results
-      return @results
-    end
+    attr_reader :results
 
     def validate_configuration
-      @rules.each do |rule|
-        rule.validate_configuration
-      end
+      @rules.each(&:validate_configuration)
     end
 
     def to_s
-      @rules.map { |rule|
-        rule.to_s
-      }.join("\n")
+      @rules.map(&:to_s).join("\n")
     end
   end
 end

data/lib/anodator/utils.rb

@@ -1,4 +1,4 @@
-require "csv"
+require 'csv'
 
 module Anodator
   module Utils
@@ -24,10 +24,10 @@ module Anodator
           first = false
           next
         end
-        spec << { :number => row[0], :name => row[1], :type => row[2] }
+        spec << { number: row[0], name: row[1], type: row[2] }
       end
 
-      return InputSpec.new(spec)
+      InputSpec.new(spec)
     end
 
     # load output_spec from csv file
@@ -56,8 +56,8 @@ module Anodator
     # Return:
     #   OutputSpec instance
     def self.load_output_spec_from_csv_file(file_path,
-                                       target = Anodator::OutputSpec::TARGET_ERROR,
-                                       include_no_error = false)
+                                            target = Anodator::OutputSpec::TARGET_ERROR,
+                                            include_no_error = false)
       first = true
       header = nil
       spec = []
@@ -68,14 +68,14 @@ module Anodator
           first = false
           next
         end
-        if row.first.nil? || row.first.split(//).length.zero?
-          spec << row.last.to_sym
-        else
-          spec << row.first.to_s
-        end
+        spec << if row.first.nil? || row.first.split(//).length.zero?
+                  row.last.to_sym
+                else
+                  row.first.to_s
+                end
       end
 
-      return Anodator::OutputSpec.new(spec, :target => target, :include_no_error => include_no_error)
+      Anodator::OutputSpec.new(spec, target: target, include_no_error: include_no_error)
     end
 
     # options reader for option values for validator specs
@@ -89,13 +89,13 @@ module Anodator
     #   - options_index_from: index for option column be started on row(default: 4)
     # Return:
     #   Hash
-    def self.options_reader(row, options = { }, options_index_from = 4)
+    def self.options_reader(row, options = {}, options_index_from = 4)
       if row.size > options_index_from
         row[options_index_from..-1].each do |column|
           next if column.nil?
-          key, value = column.split(":", 2)
+          key, value = column.split(':', 2)
           case value
-          when "true", "false"
+          when 'true', 'false'
             options[key.to_sym] = eval(value)
           else
             options[key.to_sym] = value
@@ -103,7 +103,7 @@ module Anodator
         end
       end
 
-      return options
+      options
     end
 
     # load validators from csv file
@@ -120,7 +120,7 @@ module Anodator
     def self.load_validators_from_csv_file(file_path)
       first = true
       header = nil
-      validators = { }
+      validators = {}
 
       CSV.read(file_path).each do |row|
         # skip header
@@ -131,46 +131,42 @@ module Anodator
         end
 
         if validators.keys.include?(row[0])
-          raise ArgumentError.new("Duplicated validator number '#{row[0]}'!")
+          raise ArgumentError, "Duplicated validator number '#{row[0]}'!"
         end
 
-        options = options_reader(row, { :description => row[1] })
+        options = options_reader(row, description: row[1])
 
         validator = nil
 
         case row[2]
-        when "presence"
+        when 'presence'
           validator = Validator::PresenceValidator
-        when "blank"
+        when 'blank'
           validator = Validator::BlankValidator
-        when "date"
+        when 'date'
           validator = Validator::DateValidator
-        when "format"
+        when 'format'
           validator = Validator::FormatValidator
-        when "inclusion"
+        when 'inclusion'
           validator = Validator::InclusionValidator
-          unless options[:in].nil?
-            options[:in] = options[:in].split(",")
-          end
-        when "length"
+          options[:in] = options[:in].split(',') unless options[:in].nil?
+        when 'length'
           validator = Validator::LengthValidator
-        when "numeric"
+        when 'numeric'
           validator = Validator::NumericValidator
-        when "complex"
-          options[:validators] = row[3].split(",").map do |validator_number|
+        when 'complex'
+          options[:validators] = row[3].split(',').map do |validator_number|
             validators[validator_number]
           end
           validators[row[0]] = Validator::ComplexValidator.new(options)
         else
-          raise ArgumentError.new("Unknown validator type '#{row[2]}'!")
+          raise ArgumentError, "Unknown validator type '#{row[2]}'!"
         end
 
-        if validator
-          validators[row[0]] = validator.new(row[3], options)
-        end
+        validators[row[0]] = validator.new(row[3], options) if validator
       end
 
-      return validators
+      validators
     end
 
     # load rule_set from csv file
@@ -200,19 +196,17 @@ module Anodator
         end
 
         description = row[1]
-        target_expression = row[2].split(",")
+        target_expression = row[2].split(',')
         validator = validators[row[3]]
-        if !row[4].nil? && row[4].include?(",")
-          prerequisite = row[4].split(",").map do |validator_id|
+        if !row[4].nil? && row[4].include?(',')
+          prerequisite = row[4].split(',').map do |validator_id|
             raise "Unknown validator identifier '#{validator_id}'" if validators[validator_id].nil?
             next validators[validator_id]
           end
         else
           prerequisite = validators[row[4]]
         end
-        if validator.nil?
-          raise "Unknown validator identifier '#{row[3]}'"
-        end
+        raise "Unknown validator identifier '#{row[3]}'" if validator.nil?
         if !row[4].nil? && prerequisite.nil?
           raise "Unknown validator identifier '#{row[4]}'"
         end
@@ -232,7 +226,7 @@ module Anodator
                    description)
       end
 
-      return rule_set
+      rule_set
     end
   end
 end