anodator 1.0.0.pre1 → 1.0.0.pre2

data/lib/anodator/validator.rb

@@ -1,10 +1,10 @@
 # load validators
-require "anodator/validator/base"
-require "anodator/validator/blank_validator"
-require "anodator/validator/complex_validator"
-require "anodator/validator/format_validator"
-require "anodator/validator/inclusion_validator"
-require "anodator/validator/length_validator"
-require "anodator/validator/numeric_validator"
-require "anodator/validator/presence_validator"
-require "anodator/validator/date_validator"
+require 'anodator/validator/base'
+require 'anodator/validator/blank_validator'
+require 'anodator/validator/complex_validator'
+require 'anodator/validator/format_validator'
+require 'anodator/validator/inclusion_validator'
+require 'anodator/validator/length_validator'
+require 'anodator/validator/numeric_validator'
+require 'anodator/validator/presence_validator'
+require 'anodator/validator/date_validator'

data/lib/anodator/validator/base.rb

@@ -1,4 +1,4 @@
-require "anodator/validator/value_proxy"
+require 'anodator/validator/value_proxy'
 
 module Anodator
   module Validator
@@ -7,16 +7,19 @@ module Anodator
       # value of target for validation
       @@values = nil
 
+      # data source set
+      @@data_source_set = nil
+
       # valid option keys
       #
       # :allow_blank options are all available options in Validator.
       # In addition, Validator All you need to consider the case of the blank.
-      @valid_option_keys = [:allow_blank, :description]
+      @valid_option_keys = %i[allow_blank description]
 
       # default options
       #
       # Is used as the initial value was not set when you create a new Validator.
-      @default_options   = { :allow_blank => false }
+      @default_options   = { allow_blank: false }
 
       # target specify value
       attr_reader :target
@@ -32,43 +35,41 @@ module Anodator
         def valid_option_keys(*option_keys)
           # initialize from superclass
           if @valid_option_keys.nil?
-            @valid_option_keys = self.superclass.valid_option_keys
+            @valid_option_keys = superclass.valid_option_keys
           end
 
           unless option_keys.size.zero?
             option_keys.each do |key|
               if @valid_option_keys.include?(key)
-                raise ArgumentError.new("Validator already has option for '#{key}'")
+                raise ArgumentError, "Validator already has option for '#{key}'"
               else
                 @valid_option_keys << key
               end
             end
           end
 
-          return @valid_option_keys.dup
+          @valid_option_keys.dup
         end
 
         # set and/or get default options
         def default_options(options = nil)
           # initialize from superclass
-          if @default_options.nil?
-            @default_options = self.superclass.default_options
-          end
+          @default_options = superclass.default_options if @default_options.nil?
 
           unless options.nil?
             unless options.is_a? Hash
-              raise ArgumentError.new("default_options must call with Hash")
+              raise ArgumentError, 'default_options must call with Hash'
             end
             options.each do |option, default_value|
               if @valid_option_keys.include?(option)
                 @default_options[option] = default_value
               else
-                raise ArgumentError.new("Unknown option '#{option}'")
+                raise ArgumentError, "Unknown option '#{option}'"
               end
             end
           end
 
-          return @default_options.dup
+          @default_options.dup
         end
 
         # Set the data to be checked.
@@ -78,13 +79,25 @@ module Anodator
           if values.respond_to?(:[])
             @@values = values
           else
-            raise ArgumentError.new("values must be respond to [] method for validations.")
+            raise ArgumentError, 'values must be respond to [] method for validations.'
           end
         end
 
         # Get the data to be checked
         def values
-          return @@values
+          @@values
+        end
+
+        # Set the data source with check.
+        def data_source_set=(data_source_set)
+          msg = 'data_source_set must be Anodator::DataSourceSet'
+          raise ArgumentError, msg unless data_source_set.is_a? DataSourceSet
+
+          @@data_source_set = data_source_set
+        end
+
+        def data_source_set
+          @@data_source_set
         end
       end
 
@@ -97,13 +110,13 @@ module Anodator
       # +valid_option_keys+.
       # If necessary add additional parameters for the new validator is defined
       # in the inherited class to add.
-      def initialize(target_expression, options = { })
+      def initialize(target_expression, options = {})
         if target_expression.to_s.length.zero?
-          raise ArgumentError.new("target cannot be nil or blank")
+          raise ArgumentError, 'target cannot be nil or blank'
         else
           @target = target_expression.to_s
         end
-        @options = { }
+        @options = {}
         merge_options!(self.class.default_options)
         merge_options!(options)
       end
@@ -115,7 +128,7 @@ module Anodator
       # Can be implemented to return a boolean value to the final,
       # +valid?+ The method used is called.
       def validate
-        raise NoMethodError.new("must define method 'validate'")
+        raise NoMethodError, "must define method 'validate'"
       end
 
       # Call the +validate+ method to return a boolean value accordingly
@@ -123,7 +136,7 @@ module Anodator
       # If any exception occurs in the +validate+ method displays the contents
       # to standard error. Then raise same error.
       def valid?
-        return validate
+        validate
       end
 
       # merge options
@@ -134,7 +147,7 @@ module Anodator
           if self.class.valid_option_keys.include?(key)
             @options[key] = value
           else
-            raise ArgumentError.new("Unknown option key '#{key}'.")
+            raise ArgumentError, "Unknown option key '#{key}'."
           end
         end
       end
@@ -145,19 +158,23 @@ module Anodator
       #
       # always return String object use to_s method
       def target_value
-        return @@values[target].to_s
+        @@values[target].to_s
       end
 
       def argument_value_at(name_or_index)
-        return @@values[name_or_index].to_s
+        @@values[name_or_index].to_s
+      end
+
+      def data_source_at(identifier, key, column)
+        @@data_source_set.fetch(identifier, key, column)
       end
 
       def allow_blank?
-        return @options[:allow_blank]
+        @options[:allow_blank]
       end
 
       def description
-        return @options[:description]
+        @options[:description]
       end
 
       def proxy_value(target)
@@ -165,14 +182,14 @@ module Anodator
       end
       private :proxy_value
 
-      def to_s(level = 4, step = 2)
-        (" " * level) + "- #{self.class}(#{self.description})"
+      def to_s(level = 4, _step = 2)
+        (' ' * level) + "- #{self.class}(#{description})"
       end
 
       def validate_configuration
         @@values.spec_item_by_expression(@target)
       rescue UnknownTargetExpressionError => e
-        raise InvalidConfiguration.new(e.to_s)
+        raise InvalidConfiguration, e.to_s
       end
     end
   end

data/lib/anodator/validator/blank_validator.rb

@@ -1,4 +1,4 @@
-require "anodator/validator/base"
+require 'anodator/validator/base'
 
 module Anodator
   module Validator
@@ -7,7 +7,7 @@ module Anodator
     # This is the Validator to validate whether the value is not present.
     class BlankValidator < Base
       def validate
-        return target_value.split(//).size.zero?
+        target_value.split(//).size.zero?
       end
     end
   end

data/lib/anodator/validator/complex_validator.rb

@@ -1,4 +1,4 @@
-require "anodator/validator/configuration_error"
+require 'anodator/validator/configuration_error'
 
 module Anodator
   module Validator
@@ -6,20 +6,20 @@ module Anodator
     # Validators.
     class ComplexValidator < Base
       # Combine logical OR of each Validators
-      LOGIC_OR  = "OR"
+      LOGIC_OR  = 'OR'.freeze
       # Combine logical AND of each Validators
-      LOGIC_AND = "AND"
+      LOGIC_AND = 'AND'.freeze
 
       valid_option_keys :validators, :logic
-      default_options :logic => LOGIC_AND
+      default_options logic: LOGIC_AND
 
-      def initialize(options = { })
-        super("dummy", options)
+      def initialize(options = {})
+        super('dummy', options)
       end
 
       def validate
         if @options[:validators].nil?
-          raise ConfigurationError.new("ComplexValidator must have validators option")
+          raise ConfigurationError, 'ComplexValidator must have validators option'
         end
         case @options[:logic]
         when LOGIC_OR
@@ -33,15 +33,15 @@ module Anodator
           end
           return true
         else
-          raise ConfigurationError.new("Unknown logic option '#{@options[:logic]}")
+          raise ConfigurationError, "Unknown logic option '#{@options[:logic]}"
         end
       end
 
       def logic_expression
         if @options[:logic] == LOGIC_OR
-          return "OR"
+          'OR'
         elsif @options[:logic] == LOGIC_AND
-          return "AND"
+          'AND'
         end
       end
 
@@ -51,9 +51,9 @@ module Anodator
 
       def to_s(level = 2, step = 2)
         buf = "#{super(level, step)} LOGIC: #{logic_expression}\n"
-        buf += @options[:validators].map { |validator|
+        buf += @options[:validators].map do |validator|
           validator.to_s(level + step, step)
-        }.join("\n")
+        end.join("\n")
       end
     end
   end

data/lib/anodator/validator/configuration_error.rb

@@ -1,8 +1,7 @@
-require "anodator/anodator_error"
+require 'anodator/anodator_error'
 
 module Anodator
   module Validator
     class ConfigurationError < AnodatorError; end
   end
 end
-

data/lib/anodator/validator/date_validator.rb

@@ -1,148 +1,138 @@
-require "anodator/validator/base"
-require "date"
+require 'anodator/validator/base'
+require 'date'
 
 module Anodator
   module Validator
+    # Validator for Date expression.
     class DateValidator < Base
-      FORMAT_SCANNER_REGEXP = /((YY(?:YY)?)|(M(?![YMD]))|(MM)|(D(?![YMD]))|(DD))/
+      FORMAT_SCANNER_REGEXP =
+        /((YY(?:YY)?)|(M(?![YMD]))|(MM)|(D(?![YMD]))|(DD))/
+      HOLDER_DEFS = {
+        'YYYY' => :year,
+        'YY' => :short_year,
+        'MM' => :month,
+        'M' => :month,
+        'DD' => :day,
+        'D' => :day
+      }.freeze
+      HOLDERS = %w[YYYY YY MM M DD D].freeze
+      REGEXPS = %w[(\d{4}) (\d{2}) (\d{2}) (\d{1,2}) (\d{2}) (\d{1,2})].freeze
 
       valid_option_keys :from, :to, :format, :base_year
-      default_options :format => "YYYY-MM-DD", :base_year => 2000
+      default_options format: 'YYYY-MM-DD', base_year: 2000
 
-      def initialize(target_expression, options = { })
+      def initialize(target_expression, options = {})
         super(target_expression, options)
 
-        # format check
-        date_regexp_holders
-
-        [:from, :to].each do |key|
-          if !@options[key].nil?
-            @options[key] = proxy_value(@options[key])
-            if @options[key].direct? && !@options[key].value.is_a?(Date)
-              date = parse_date(@options[key].value.to_s)
-              if date.nil?
-                raise ArgumentError.new("Invalid date expression '#{@options[key].value}'")
-              else
-                @options[key] = proxy_value(date)
-              end
-            end
-          end
-        end
+        check_format
+        setup_period_options
       end
 
       def validate
-        if allow_blank?
-          return true if target_value.split(//).size.zero?
-        end
+        return true if allow_blank? && target_value.split(//).size.zero?
+        date = parse_date(target_value)
+        return false unless date
 
+        validate_period(date)
+      rescue ArgumentError # invalid date expression
+        return false
+      end
 
-        begin
-          # check format
-          return false unless date = parse_date(target_value)
-
-          @options.each do |option, configuration|
-            case option
-            when :from
-              return false if parse_date(configuration.value) > date
-            when :to
-              return false if parse_date(configuration.value) < date
-            end
-          end
+      def validate_period(date)
+        valid_from = from ? from_date <= date : true
+        valid_to = to ? to_date >= date : true
 
-          return true
-        rescue ArgumentError
-          # invalid date expression
-          return false
-        end
+        valid_from && valid_to
       end
 
       def from
-        if @options[:from]
-          return @options[:from].dup
-        else
-          return nil
-        end
+        @options[:from].dup
       end
 
       def to
-        if @options[:to]
-          return @options[:to].dup
-        else
-          return nil
-        end
+        @options[:to].dup
       end
 
       def format
-        return @options[:format].dup
+        @options[:format].dup
       end
 
-      # parse string with :format option
-      #
-      # not matched return nil
-      def parse_date(date_expression)
-        return date_expression if date_expression.is_a? Date
-        return nil unless match_data = date_regexp.match(date_expression)
+      def base_year
+        @options[:base_year].to_i
+      end
+
+      def from_date
+        from ? parse_date(from.value) : nil
+      end
 
-        index = 0
-        date_hash = date_regexp_holders.inject({ }) do |hash, key|
-          index += 1
-          hash[key] = match_data[index].to_i
+      def to_date
+        to ? parse_date(to.value) : nil
+      end
+
+      private
 
-          next hash
+      def setup_period_options
+        %i[from to].each do |key|
+          setup_date_option(key) if @options.key?(key)
         end
-        # for short year
-        if date_hash.keys.include?(:short_year)
-          date_hash[:year] = @options[:base_year].to_i + date_hash[:short_year]
+      end
+
+      def setup_date_option(key)
+        option = proxy_value(@options[key])
+        if option.direct? && !option.value.is_a?(Date)
+          date = parse_date(option.value.to_s)
+          msg = "Invalid date expression '#{option.value}'"
+          raise ArgumentError, msg if date.nil?
+
+          option = proxy_value(date)
         end
 
-        return Date.new(date_hash[:year], date_hash[:month], date_hash[:day])
+        @options[key] = option
       end
-      private :parse_date
 
-      def date_regexp
-        date_regexp_holders # check format string
+      def parse_date(date_expression)
+        return date_expression if date_expression.is_a? Date
+        return nil unless date_regexp.match(date_expression)
 
-        regexp_string = @options[:format].dup
-        regexp_string.sub!(/YYYY/, '(\d{4})')
-        regexp_string.sub!(/YY/,   '(\d{2})')
-        regexp_string.sub!(/MM/,   '(\d{2})')
-        regexp_string.sub!(/M/,    '(\d{1,2})')
-        regexp_string.sub!(/DD/,   '(\d{2})')
-        regexp_string.sub!(/D/,    '(\d{1,2})')
+        date_hash = date_regexp_holders.each_with_object({})
+                                       .with_index(1) do |(key, hash), i|
+          hash[key] = Regexp.last_match[i].to_i
+        end
+        convert_short_year(date_hash)
+        Date.new(date_hash[:year], date_hash[:month], date_hash[:day])
+      end
 
-        return Regexp.new("^#{regexp_string}$")
+      def convert_short_year(hash)
+        hash[:year] = base_year + hash[:short_year] if hash.key?(:short_year)
       end
-      private :date_regexp
 
-      def date_regexp_holders
-        scans = @options[:format].scan FORMAT_SCANNER_REGEXP
-        year_count, month_count, day_count = 0, 0, 0
-        holders = scans.map do |scan|
-          case scan.first
-          when "YYYY"
-            year_count += 1
-            :year
-          when "YY"
-            year_count += 1
-            :short_year
-          when "MM", "M"
-            month_count += 1
-            :month
-          when "DD", "D"
-            day_count += 1
-            :day
-          end
+      def date_regexp
+        regexp_string = HOLDERS.each_with_index.inject(format) do |s, (h, i)|
+          s.sub(/#{h}/, REGEXPS[i])
         end
-        unless holders.size == 3
-          raise ArgumentError.new("date format must be contained year(YYYY or YY), month(MM or M) and day(DD or D).")
+
+        /^#{regexp_string}$/
+      end
+
+      def date_regexp_holders
+        format.scan(FORMAT_SCANNER_REGEXP).map do |scan|
+          HOLDER_DEFS[scan.first]
         end
-        unless year_count == 1 && month_count == 1 && day_count == 1
-          raise ArgumentError.new("date format must be contained year(YYYY or YY), month(MM or M) and day(DD or D).")
+      end
+
+      def check_format
+        msg = 'date format must be contained year(YYYY or YY), ' \
+              'month(MM or M) and day(DD or D).'
+        hash = { year: :year, month: :month, day: :day, short_year: :year }
+
+        checked_holders = date_regexp_holders.inject([]) do |array, holder|
+          array << hash[holder]
         end
 
-        return holders
+        raise ArgumentError, msg if checked_holders.include?(nil)
+        raise ArgumentError, msg unless checked_holders.size == 3
+        raise ArgumentError, msg unless checked_holders.uniq!.nil?
       end
-      private :date_regexp_holders
     end
   end
 end