anodator 0.0.1

data/lib/anodator/validator/base.rb

@@ -0,0 +1,168 @@
+module Anodator
+  module Validator
+    # +Validator::Base+ is basic class for validations
+    class Base
+      # value of target for validation
+      @@values = 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]
+
+      # default options
+      #
+      # Is used as the initial value was not set when you create a new Validator.
+      @default_options   = { :allow_blank => false }
+
+      # target specify value
+      attr_reader :target
+
+      # option values
+      attr_reader :options
+
+      # @@valid_option_keys = [:allow_blank]
+
+      # class methods
+      class << self
+        # set and/or get valid option keys
+        def valid_option_keys(*option_keys)
+          # initialize from superclass
+          if @valid_option_keys.nil?
+            @valid_option_keys = self.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}'")
+              else
+                @valid_option_keys << key
+              end
+            end
+          end
+
+          return @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
+
+          unless options.nil?
+            unless options.is_a? Hash
+              raise ArgumentError.new("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}'")
+              end
+            end
+          end
+
+          return @default_options.dup
+        end
+
+        # Set the data to be checked.
+        #
+        # Data to be checked can be set to any object that responds to [].
+        def values=(values)
+          if values.respond_to?(:[])
+            @@values = values
+          else
+            raise ArgumentError.new("values must be respond to [] method for validations.")
+          end
+        end
+
+        # Get the data to be checked
+        def values
+          return @@values
+        end
+      end
+
+      # initializer
+      #
+      # Specify +options+ as an additional parameter to hold the verification
+      # and other options for specifying the +target_expression+ be verified.
+      # The default options are optional and will be an empty hash.
+      # Key to use additional parameters are stored in class variable
+      # +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 = { })
+        if target_expression.to_s.length.zero?
+          raise ArgumentError.new("target cannot be nil or blank")
+        else
+          @target = target_expression.to_s
+        end
+        @options = { }
+        merge_options!(self.class.default_options)
+        merge_options!(options)
+      end
+
+      # validation method
+      #
+      # +validate+ method must be defined in a class that inherits.
+      # In the +validate+ method implements the verification method.
+      # 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'")
+      end
+
+      # Call the +validate+ method to return a boolean value accordingly
+      #
+      # If any exception occurs in the +validate+ method displays the contents
+      # to standard error. Then raise same error.
+      def valid?
+        return validate
+      end
+
+      # merge options
+      #
+      # If the key parameter is illegal to throw an ArgumentError.
+      def merge_options!(options)
+        options.each do |key, value|
+          if self.class.valid_option_keys.include?(key)
+            @options[key] = value
+          else
+            raise ArgumentError.new("Unknown option key '#{key}'.")
+          end
+        end
+      end
+
+      private :merge_options!
+
+      # target_value
+      #
+      # always return String object use to_s method
+      def target_value
+        return @@values[target].to_s
+      end
+
+      def allow_blank?
+        return @options[:allow_blank]
+      end
+
+      def description
+        return @options[:description]
+      end
+
+      def to_s(level = 4, step = 2)
+        (" " * level) + "- #{self.class}(#{self.description})"
+      end
+
+      def validate_configuration
+        @@values.spec_item_by_expression(@target)
+      rescue UnknownTargetExpressionError => e
+        raise InvalidConfiguration.new(e.to_s)
+      end
+    end
+  end
+end

data/lib/anodator/validator/blank_validator.rb

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

data/lib/anodator/validator/complex_validator.rb

@@ -0,0 +1,60 @@
+require "anodator/validator/configuration_error"
+
+module Anodator
+  module Validator
+    # ComplexValidator behaves like a single Validator what contains multiple
+    # Validators.
+    class ComplexValidator < Base
+      # Combine logical OR of each Validators
+      LOGIC_OR  = "OR"
+      # Combine logical AND of each Validators
+      LOGIC_AND = "AND"
+
+      valid_option_keys :validators, :logic
+      default_options :logic => LOGIC_AND
+
+      def initialize(options = { })
+        super("dummy", options)
+      end
+
+      def validate
+        if @options[:validators].nil?
+          raise ConfigurationError.new("ComplexValidator must have validators option")
+        end
+        case @options[:logic]
+        when LOGIC_OR
+          @options[:validators].each do |validator|
+            return true if validator.valid?
+          end
+          return false
+        when LOGIC_AND
+          @options[:validators].each do |validator|
+            return false unless validator.valid?
+          end
+          return true
+        else
+          raise ConfigurationError.new("Unknown logic option '#{@options[:logic]}")
+        end
+      end
+
+      def logic_expression
+        if @options[:logic] == LOGIC_OR
+          return "OR"
+        elsif @options[:logic] == LOGIC_AND
+          return "AND"
+        end
+      end
+
+      def validate_configuration
+        # target check skip
+      end
+
+      def to_s(level = 2, step = 2)
+        buf = "#{super(level, step)} LOGIC: #{logic_expression}\n"
+        buf += @options[:validators].map { |validator|
+          validator.to_s(level + step, step)
+        }.join("\n")
+      end
+    end
+  end
+end

data/lib/anodator/validator/configuration_error.rb

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

data/lib/anodator/validator/date_validator.rb

@@ -0,0 +1,151 @@
+require "anodator/validator/base"
+require "date"
+
+module Anodator
+  module Validator
+    class DateValidator < Base
+      FORMAT_SCANNER_REGEXP = /((YY(?:YY)?)|(M(?![YMD]))|(MM)|(D(?![YMD]))|(DD))/
+
+      valid_option_keys :from, :to, :format, :base_year
+      default_options :format => "YYYY-MM-DD", :base_year => 2000
+
+      def initialize(target_expression, options = { })
+        super(target_expression, options)
+
+        # format check
+        date_regexp_holders
+
+        if !@options[:from].nil? && !@options[:from].is_a?(Date)
+          date = parse_date(@options[:from].to_s)
+          if date.nil?
+            raise ArgumentError.new("Invalid date expression '#{@options[:from]}'")
+          else
+            @options[:from] = date
+          end
+        end
+
+        if !@options[:to].nil? && !@options[:to].is_a?(Date)
+          date = parse_date(@options[:to].to_s)
+          if date.nil?
+            raise ArgumentError.new("Invalid date expression '#{@options[:to]}'")
+          else
+            @options[:to] = date
+          end
+        end
+      end
+
+      def validate
+        if allow_blank?
+          return true if target_value.split(//).size.zero?
+        end
+
+
+        begin
+          # check format
+          return false unless date = parse_date(target_value)
+
+          @options.each do |option, configuration|
+            case option
+            when :from
+              return false if configuration > date
+            when :to
+              return false if configuration < date
+            end
+          end
+
+          return true
+        rescue ArgumentError
+          # invalid date expression
+          return false
+        end
+      end
+
+      def from
+        if @options[:from]
+          return @options[:from].dup
+        else
+          return nil
+        end
+      end
+
+      def to
+        if @options[:to]
+          return @options[:to].dup
+        else
+          return nil
+        end
+      end
+
+      def format
+        return @options[:format].dup
+      end
+
+      # parse string with :format option
+      #
+      # not matched return nil
+      def parse_date(date_expression)
+        return nil unless match_data = date_regexp.match(date_expression)
+
+        index = 0
+        date_hash = date_regexp_holders.inject({ }) do |hash, key|
+          index += 1
+          hash[key] = match_data[index].to_i
+
+          next hash
+        end
+        # for short year
+        if date_hash.keys.include?(:short_year)
+          date_hash[:year] = @options[:base_year].to_i + date_hash[:short_year]
+        end
+
+        return Date.new(date_hash[:year], date_hash[:month], date_hash[:day])
+      end
+      private :parse_date
+
+      def date_regexp
+        date_regexp_holders # check format string
+
+        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})')
+
+        return Regexp.new("^#{regexp_string}$")
+      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
+        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).")
+        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
+
+        return holders
+      end
+      private :date_regexp_holders
+    end
+  end
+end

data/lib/anodator/validator/format_validator.rb

@@ -0,0 +1,48 @@
+require "anodator/validator/base"
+require "anodator/validator/configuration_error"
+
+module Anodator
+  module Validator
+    class FormatValidator < Base
+      ALL_ZENKAKU_REGEXP = /(?:\xEF\xBD[\xA1-\xBF]|\xEF\xBE[\x80-\x9F])|[\x20-\x7E]/
+
+      valid_option_keys :format, :all_zenkaku
+      default_options :all_zenkaku => false
+
+      def initialize(target_expression, options = { })
+        super(target_expression, options)
+
+        if @options[:format].is_a? String
+          @options[:format] = Regexp.new("#{@options[:format]}")
+        end
+      end
+
+      def validate
+        if target_value.split(//).size.zero?
+          if allow_blank?
+            return true
+          end
+        end
+
+
+        if @options[:all_zenkaku]
+          return target_value !~ ALL_ZENKAKU_REGEXP
+        else
+          unless @options[:format].is_a? Regexp
+            raise ConfigurationError.new(":format option must be Regexp object")
+          end
+
+          if @options[:format].match target_value
+            return true
+          else
+            return false
+          end
+        end
+      end
+
+      def format
+        return @options[:format].dup
+      end
+    end
+  end
+end

data/lib/anodator/validator/inclusion_validator.rb

@@ -0,0 +1,21 @@
+require "anodator/validator/base"
+
+module Anodator
+  module Validator
+    class InclusionValidator < Base
+      valid_option_keys :in
+
+      def validate
+        if allow_blank?
+          return true if target_value.split(//).size.zero?
+        end
+
+        unless @options[:in].respond_to? :include?
+          raise ConfigurationError.new(":in option must be responed_to include?")
+        end
+
+        return @options[:in].include?(target_value)
+      end
+    end
+  end
+end

data/lib/anodator/validator/length_validator.rb

@@ -0,0 +1,37 @@
+require "anodator/validator/base"
+require "anodator/validator/configuration_error"
+
+module Anodator
+  module Validator
+    class LengthValidator < Base
+      valid_option_keys :in, :maximum, :minimum, :is
+
+      def validate
+        length = target_value.split(//).size
+
+        if allow_blank?
+          return true if length.zero?
+        end
+
+        @options.each do |option, configuration|
+          case option
+          when :in
+            if configuration.is_a? Range
+              return false unless configuration.include?(length)
+            else
+              raise ConfigurationError.new(":in option value must be Range object")
+            end
+          when :maximum
+            return false if length > configuration.to_i
+          when :minimum
+            return false if length < configuration.to_i
+          when :is
+            return false if length != configuration.to_i
+          end
+        end
+
+        return true
+      end
+    end
+  end
+end

data/lib/anodator/validator/numeric_validator.rb

@@ -0,0 +1,46 @@
+require "anodator/validator/base"
+require "bigdecimal"
+
+module Anodator
+  module Validator
+    class NumericValidator < Base
+      valid_option_keys :only_integer, :greater_than, :greater_than_or_equal_to
+      valid_option_keys :less_than, :less_than_or_equal_to, :equal_to
+      default_options :only_integer => false
+
+      def validate
+        if allow_blank?
+          return true if target_value.split(//).size.zero?
+        end
+
+        # check format
+        if @options[:only_integer]
+          regexp = /^-?\d+$/
+        else
+          regexp = /^-?\d+(\.\d+)?$/
+        end
+        return false unless regexp.match target_value
+
+        # convert BigDecimal value
+        value = BigDecimal.new(target_value)
+
+        @options.each do |option, configuration|
+          case option
+          when :greater_than
+            return false unless value > BigDecimal.new(configuration.to_s)
+          when :greater_than_or_equal_to
+            return false unless value >= BigDecimal.new(configuration.to_s)
+          when :less_than
+            return false unless value < BigDecimal.new(configuration.to_s)
+          when :less_than_or_equal_to
+            return false unless value <= BigDecimal.new(configuration.to_s)
+          when :equal_to
+            return false unless value == BigDecimal.new(configuration.to_s)
+          end
+        end
+
+        return true
+      end
+    end
+  end
+end

data/lib/anodator/validator/presence_validator.rb

@@ -0,0 +1,14 @@
+require "anodator/validator/base"
+
+module Anodator
+  module Validator
+    # presence validator
+    #
+    # This is the Validator to validate whether the value is present.
+    class PresenceValidator < Base
+      def validate
+        return !target_value.split(//).size.zero?
+      end
+    end
+  end
+end

data/lib/anodator/validator.rb

@@ -0,0 +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"

data/lib/anodator.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
+
+require "anodator/checker"

data/spec/anodator/check_result_spec.rb

@@ -0,0 +1,101 @@
+require "spec_helper"
+
+# Anodator::CheckResult
+require "anodator/check_result"
+
+include Anodator
+
+describe CheckResult, ".new" do
+  context "with no parameters" do
+    it "should raise error ArgumentError" do
+      lambda {
+        CheckResult.new
+      }.should raise_error ArgumentError
+    end
+  end
+
+  context "with only target_numbers" do
+    it "should raise error ArgumentError" do
+      lambda {
+        CheckResult.new(["1", "2"])
+      }.should raise_error ArgumentError
+    end
+  end
+
+  context "with target_numbers and message" do
+    before(:each) do
+      @new_proc = lambda {
+        CheckResult.new(["1", "2"], "An error occured for 1 and 2 values.")
+      }
+    end
+
+    it "should raise ArgumentError" do
+      @new_proc.should raise_error ArgumentError
+    end
+  end
+  context "with target_numbers, message and level" do
+    before(:each) do
+      @new_proc = lambda {
+        CheckResult.new(["1", "2"], "An error occured for 1 and 2 values.", Rule::LEVEL_ERROR)
+      }
+    end
+
+    it "should not raise error" do
+      @new_proc.should_not raise_error
+    end
+
+    context "after generated" do
+      before(:each) do
+        @check_result = @new_proc.call
+      end
+
+      it "#target_numbers should be set" do
+        @check_result.target_numbers.should == ["1", "2"]
+      end
+
+      it "#message should be set" do
+        @check_result.message.should == "An error occured for 1 and 2 values."
+      end
+
+      it "#level should be set" do
+        @check_result.level.should == Rule::LEVEL_ERROR
+      end
+    end
+  end
+end
+
+describe CheckResult, "#error?" do
+  context "when level is error" do
+    before(:each) do
+      @check_result = CheckResult.new("1", "message", Rule::LEVEL_ERROR)
+    end
+
+    it { @check_result.should be_error }
+  end
+
+  context "when level is warning" do
+    before(:each) do
+      @check_result = CheckResult.new("1", "message", Rule::LEVEL_WARNING)
+    end
+
+    it { @check_result.should_not be_error }
+  end
+end
+
+describe CheckResult, "#warning?" do
+  context "when level is error" do
+    before(:each) do
+      @check_result = CheckResult.new("1", "message", Rule::LEVEL_ERROR)
+    end
+
+    it { @check_result.should_not be_warning }
+  end
+
+  context "when level is warning" do
+    before(:each) do
+      @check_result = CheckResult.new("1", "message", Rule::LEVEL_WARNING)
+    end
+
+    it { @check_result.should be_warning }
+  end
+end