anodator 0.0.1

data/lib/anodator/message.rb

@@ -0,0 +1,59 @@
+require "anodator/anodator_error"
+
+module Anodator
+  class UnknownMessageAttributeError < AnodatorError ; end
+
+  # Message is error message builder.
+  #
+  # Message is generated with formated string for expand several keywords.
+  # Message#expand method is expand keywords by data_provider suppried by parameter.
+  class Message < String
+    # message
+    attr_reader :template
+
+    def initialize(template_message)
+      @template = template_message.to_s
+
+      if @template.split(//).size.zero?
+        raise ArgumentError.new("template_message cannot be blank")
+      end
+    end
+
+    # expand message with data_provider
+    #
+    # message keyword is expressed +[[target_expression::attribute]]+.
+    # data_provider is data source for current check target.
+    #
+    # - target_expression: specify target.
+    # - attribute: actual printed value
+    #   - name:   target name
+    #   - number: target number
+    #   - 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.name
+        when "number"
+          spec_item.number
+        when "value"
+          data_provider[$1]
+        else
+          raise UnknownMessageAttributeError.new("Unknown message attribute '#{$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}'")
+        end
+      end
+    rescue UnknownTargetExpressionError, UnknownMessageAttributeError => e
+      raise InvalidConfiguration.new(e.to_s)
+    end
+  end
+end

data/lib/anodator/output_spec.rb

@@ -0,0 +1,164 @@
+module Anodator
+  class OutputSpec
+    TARGET_DATA  = "DATA"
+    TARGET_ERROR = "ERROR"
+
+    VALID_SYMBOL_ITEMS = [
+                          :target_numbers,
+                          :target_names,
+                          :target_values,
+                          :error_message,
+                          :error_level,
+                          :error_count,
+                          :warning_count,
+                          :error_and_warning_count,
+                         ]
+
+    attr_reader   :items, :target, :include_no_error
+    attr_accessor :separator, :value_separator
+
+    def initialize(items = [], options = { })
+      @items            = items.to_a
+      @target           = TARGET_ERROR
+      @include_no_error = false
+      @separator        = " "
+      @value_separator  = ""
+
+      options.each do |key, opt|
+        case key
+        when :target
+          @target = opt
+        when :include_no_error
+          @include_no_error = !!opt
+        when :separator, :value_separator
+          @separator = opt.to_s
+        else
+          raise ArgumentError.new("unknown option #{key}.")
+        end
+      end
+
+      unless [TARGET_DATA, TARGET_ERROR].include?(@target)
+        raise ArgumentError.new("unknown target option value #{@target}.")
+      end
+
+      check_items
+    end
+
+    def validate_configuration
+      @items.each do |item|
+        if item.is_a? String
+          Validator::Base.values.spec_item_at_by_number(item)
+        end
+      end
+    rescue UnknownTargetExpressionError => e
+      raise InvalidConfiguration.new(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
+        end
+      end
+    end
+    private :check_items
+
+    def generate(input_spec_with_values, check_results)
+      if @target == TARGET_DATA
+        generate_data(input_spec_with_values, check_results)
+      else # @target == TARGET_ERROR
+        generate_error(input_spec_with_values, check_results)
+      end
+    end
+
+    def generate_data(input_spec_with_values, check_results)
+      buf = []
+      buf << @items.map do |item|
+        if item.is_a? Symbol
+          case item
+          when :error_count
+            next check_results.map { |result|
+              result.error? ? true : nil
+            }.compact.size.to_s
+          when :warning_count
+            next check_results.map { |result|
+              result.warning? ? true : nil
+            }.compact.size.to_s
+          when :error_and_warning_count
+            next check_results.size.to_s
+          else
+            next ""
+          end
+        else # data
+          next input_spec_with_values[item]
+        end
+      end
+
+      return buf
+    end
+    private :generate_data
+
+    def generate_error(input_spec_with_values, check_results)
+      buf = []
+
+      if check_results.size.zero?
+        if @include_no_error
+          buf << @items.map do |item|
+            if item.is_a? Symbol
+              case item
+              when :error_count, :warning_count, :error_and_warning_count
+                next "0"
+              else
+                next ""
+              end
+            else # data
+              next input_spec_with_values[item]
+            end
+          end
+        end
+      else
+        check_results.each do |check_result|
+          buf << @items.map do |item|
+            if item.is_a? Symbol
+              case item
+              when :target_numbers
+                next check_result.target_numbers.join(@separator)
+              when :target_names
+                next check_result.target_numbers.map { |number|
+                  input_spec_with_values.spec_item_at_by_number(number).name
+                }.join(@separator)
+              when :target_values
+                next check_result.target_numbers.map { |number|
+                  input_spec_with_values[number]
+                }.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|
+                  result.error? ? true : nil
+                }.compact.size.to_s
+              when :warning_count
+                next check_results.map { |result|
+                  result.warning? ? true : nil
+                }.compact.size.to_s
+              when :error_and_warning_count
+                next check_results.size.to_s
+              else
+                next ""
+              end
+            else # data
+              next input_spec_with_values[item]
+            end
+          end
+        end
+      end
+
+      return buf
+    end
+    private :generate_error
+  end
+end

data/lib/anodator/rule.rb

@@ -0,0 +1,97 @@
+require "anodator/message"
+require "anodator/validator"
+require "anodator/check_result"
+
+module Anodator
+  # Check rule
+  #
+  # Rule has target expressions, prerequisite, validator and message.
+  # "Prerequisite" is represented by the Validator.
+  class Rule
+    # Check level ERROR
+    LEVEL_ERROR   = 2
+    # Check level WARNING
+    LEVEL_WARNING = 1
+
+    attr_reader :target_expressions, :message, :validator, :prerequisite, :level, :description
+
+    def initialize(target_expressions, message, validator, prerequisite = nil, level = LEVEL_ERROR, description = nil)
+      @target_expressions = target_expressions.to_a
+      @message            = message
+      @validator          = validator
+      @prerequisite       = prerequisite
+      @level              = level
+      @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")
+      end
+      unless [LEVEL_ERROR, LEVEL_WARNING].include?(@level)
+        raise ArgumentError.new("level must be ERROR or WARNING")
+      end
+    end
+
+    # check values depend on prerequisite and validator
+    #
+    # When invalid, return CheckResult object, but when valid
+    # return nil.
+    def check
+      unless @prerequisite.nil?
+        unless @prerequisite.valid?
+          return nil
+        end
+      end
+
+      if @validator.valid?
+        return nil
+      else
+        numbers = @target_expressions.map do |target_expression|
+          Validator::Base.values.spec_item_by_expression(target_expression).number
+        end
+
+        CheckResult.new(numbers,
+                        @message.expand(Validator::Base.values),
+                        @level)
+      end
+    end
+
+    def validate_configuration
+      @target_expressions.each do |target_expression|
+        Validator::Base.values.spec_item_by_expression(target_expression)
+      end
+      @message.validate_configuration
+      @validator.validate_configuration
+      @prerequisite.validate_configuration unless @prerequisite.nil?
+    rescue UnknownTargetExpressionError => e
+      raise InvalidConfiguration.new(e.to_s)
+    end
+
+    def level_expression
+      if @level == LEVEL_ERROR
+        return "ERROR"
+      elsif @level == LEVEL_WARNING
+        return "WARNING"
+      end
+    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}
+  Targets: #{target_names}
+  Message: #{@message.template}
+  Level: #{level_expression}
+  Validator:
+#{@validator.to_s}
+  Prerequisite:
+#{@prerequisite.nil? ? "    - (None)" : @prerequisite.to_s}
+_EOD_
+    end
+  end
+end

data/lib/anodator/rule_set.rb

@@ -0,0 +1,52 @@
+require "anodator/rule"
+
+module Anodator
+  class RuleSet
+    def initialize
+      @rules   = []
+      @results = []
+    end
+
+    def add_rule(rule)
+      if rule.is_a? Rule
+        @rules << rule
+      else
+        raise ArgumentError.new("rule must be Anodator::Rule object")
+      end
+    end
+
+    alias_method :<<, :add_rule
+
+    def check_all
+      @results = []
+
+      if @rules.count.zero?
+        return false
+      else
+        @rules.each do |rule|
+          if result = rule.check
+            @results << result
+          end
+        end
+
+        return true
+      end
+    end
+
+    def results
+      return @results
+    end
+
+    def validate_configuration
+      @rules.each do |rule|
+        rule.validate_configuration
+      end
+    end
+
+    def to_s
+      @rules.map { |rule|
+        rule.to_s
+      }.join("\n")
+    end
+  end
+end

data/lib/anodator/utils.rb

@@ -0,0 +1,234 @@
+require "csv"
+
+module Anodator
+  module Utils
+    # load input_spec from csv file
+    #
+    # File encoding: UTF-8
+    # Columns:
+    #   - column identification(string)
+    #   - column name(string)
+    #   - column type(STRING, NUMERIC or DATE, default is STRING)
+    # Arguments:
+    #   - file_path: file path for input spec.
+    # Return:
+    #   InputSpec instance
+    def self.load_input_spec_from_csv_file(file_path)
+      first = true
+      header = nil
+      spec = []
+      CSV.open(file_path, "r") do |row|
+        # skip header
+        if first
+          header = row
+          first = false
+          next
+        end
+        spec << { :number => row[0], :name => row[1], :type => row[2] }
+      end
+
+      return InputSpec.new(spec)
+    end
+
+    # load output_spec from csv file
+    #
+    # When target is TARGET_ERROR generate output line by one error,
+    # when target is TARGET_DATA generate output line by one data.
+    # When set include_no_error is true and target is TARGET_DATA,
+    # generate output line has no error.
+    #
+    # File encoding: UTF-8
+    # Columns:
+    #   - output column identification(string)
+    #   - output special column(string)
+    #     - target_numbers(for error)
+    #     - target_names(for one error)
+    #     - target_values(for one error)
+    #     - error_message(for one error)
+    #     - error_level(for one error)
+    #     - error_count(for one error)
+    #     - warning_count(for one data)
+    #     - error_and_warning_count(for one data)
+    # Arguments:
+    #   - file_path: file path for output spec.
+    #   - target: OutputSpec::TARGET_ERROR or OutputSpec::TARGET_DATA
+    #   - include_no_error: true or false(default false)
+    # Return:
+    #   OutputSpec instance
+    def self.load_output_spec_from_csv_file(file_path,
+                                       target = Anodator::OutputSpec::TARGET_ERROR,
+                                       include_no_error = false)
+      first = true
+      header = nil
+      spec = []
+      CSV.open(file_path, "r") do |row|
+        # skip header
+        if first
+          header = row
+          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
+      end
+
+      return Anodator::OutputSpec.new(spec, :target => target, :include_no_error => include_no_error)
+    end
+
+    # options reader for option values for validator specs
+    #
+    # When value is 'true' or 'false', convert true or false instance.
+    # The others set to string.
+    #
+    # Arguments:
+    #   - row: validator line string
+    #   - options: default options
+    #   - 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)
+      if row.size > options_index_from
+        row[options_index_from..-1].each do |column|
+          next if column.nil?
+          key, value = column.split(":", 2)
+          case value
+          when "true", "false"
+            options[key.to_sym] = eval(value)
+          else
+            options[key.to_sym] = value
+          end
+        end
+      end
+
+      return options
+    end
+
+    # load validators from csv file
+    #
+    # File encoding: UTF-8
+    # Columns:
+    #   - validator identification(string)
+    #   - validation name(string)
+    #   - validator type(string)
+    #   - target expression(string)
+    #   - options...
+    # Return:
+    #   Hash for validators(key is identification, value is validator)
+    def self.load_validators_from_csv_file(file_path)
+      first = true
+      header = nil
+      validators = { }
+
+      CSV.open(file_path, "r") do |row|
+        # skip header
+        if first
+          header = row
+          first = false
+          next
+        end
+
+        if validators.keys.include?(row[0])
+          raise ArgumentError.new("Duplicated validator number '#{row[0]}'!")
+        end
+
+        options = options_reader(row, { :description => row[1] })
+
+        validator = nil
+
+        case row[2]
+        when "presence"
+          validator = Validator::PresenceValidator
+        when "blank"
+          validator = Validator::BlankValidator
+        when "date"
+          validator = Validator::DateValidator
+        when "format"
+          validator = Validator::FormatValidator
+        when "inclusion"
+          validator = Validator::InclusionValidator
+          unless options[:in].nil?
+            options[:in] = options[:in].split(",")
+          end
+        when "length"
+          validator = Validator::LengthValidator
+        when "numeric"
+          validator = Validator::NumericValidator
+        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]}'!")
+        end
+
+        if validator
+          validators[row[0]] = validator.new(row[3], options)
+        end
+      end
+
+      return validators
+    end
+
+    # load rule_set from csv file
+    #
+    # File encoding: UTF-8
+    # Columns:
+    #   - rule identification(string)
+    #   - rule description(string)
+    #   - target expression(column identification or column name)
+    #   - validator identification
+    #   - prerequisite validator identification(allow blank)
+    #   - error level(ERROR or WARNING)
+    #   - error message holder(string)
+    # Return:
+    #   RuleSet instance
+    def self.load_rule_from_csv_file(file_path, validators)
+      first = true
+      header = nil
+      rule_set = RuleSet.new
+
+      CSV.open(file_path, "r") do |row|
+        # skip header
+        if first
+          header = row
+          first = false
+          next
+        end
+
+        description = row[1]
+        target_expression = row[2].split(",")
+        validator = validators[row[3]]
+        prerequisite = validators[row[4]]
+        if validator.nil?
+          raise "Unknown validator identifier '#{row[3]}'"
+        end
+        if !row[4].nil? && prerequisite.nil?
+          raise "Unknown validator identifier '#{row[4]}'"
+        end
+        level = case row[5]
+                when "ERROR"
+                  Rule::LEVEL_ERROR
+                when "WARNING"
+                  Rule::LEVEL_WARNING
+                else
+                  raise "Unknown error type '#{row[5]}'"
+                end
+        message = Message.new(row[6])
+
+        rule_set <<
+          Rule.new(target_expression,
+                   message,
+                   validator,
+                   prerequisite,
+                   level,
+                   description)
+      end
+
+      return rule_set
+    end
+  end
+end