anodator 0.0.1 → 0.0.2

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/lib/anodator/check_result.rb

@@ -15,27 +15,24 @@ module Anodator
       if @message.split(//).size.zero?
         raise ArgumentError.new("message cannot be blank")
       end
-      unless [Rule::LEVEL_ERROR, Rule::LEVEL_WARNING].include?(level)
-        raise ArgumentError.new("level must be ERROR or WARNING")
+      unless Rule::ERROR_LEVELS.values.include?(level)
+        raise ArgumentError.new("level must be #{Rule::ERROR_LEVEL_NAMES.join(", ")}")
       end
     end
 
     def to_s
-      buf = "[      ]\t"
-      if @level == Rule::LEVEL_WARNING
-        buf = "[WARING]\t"
-      else
-        buf = "[ERROR ]\t"
-      end
+      buf = "[#{Rule.level_expression(@level)}]\t"
       buf += @message + " |#{@target_numbers.join(", ")}|"
     end
 
-    def error?
-      return Rule::LEVEL_ERROR == @level
-    end
+    def method_missing(message, *args)
+      if message.to_s =~ /(\A[a-zA-Z_]+)\?\Z/
+        if Rule::ERROR_LEVELS.keys.include?($1.to_sym)
+          return Rule::ERROR_LEVELS[$1.to_sym] == @level
+        end
+      end
 
-    def warning?
-      return Rule::LEVEL_WARNING == @level
+      super
     end
   end
 end

data/lib/anodator/rule.rb

@@ -8,14 +8,54 @@ module Anodator
   # 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
+    # Check levels
+    #
+    # default levels are error and warning.
+    # You can add any levels.
+    ERROR_LEVELS = {
+      :error   => 2, # ERROR
+      :warning => 1, # WARNING
+    }
+
+    # Check level names
+    #
+    # Check level name labels
+    ERROR_LEVEL_NAMES = {
+      :error   => "ERROR",
+      :warning => "WARNING",
+    }
 
     attr_reader :target_expressions, :message, :validator, :prerequisite, :level, :description
 
-    def initialize(target_expressions, message, validator, prerequisite = nil, level = LEVEL_ERROR, description = nil)
+    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 #{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 #{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 #{label} already exists" if ERROR_LEVEL_NAMES.values.include?(label)
+
+      # check OK
+      ERROR_LEVELS[symbol] = value
+      ERROR_LEVEL_NAMES[symbol] = label
+    end
+
+    def self.remove_error_level(symbol)
+      # 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
+
+      # check OK
+      ERROR_LEVELS.delete(symbol)
+      ERROR_LEVEL_NAMES.delete(symbol)
+    end
+
+    def initialize(target_expressions, message, validator, prerequisite = nil, level = ERROR_LEVELS.values.sort.last, description = nil)
       @target_expressions = target_expressions.to_a
       @message            = message
       @validator          = validator
@@ -32,8 +72,8 @@ module Anodator
       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")
+      unless ERROR_LEVELS.values.include?(@level)
+        raise ArgumentError.new("level must be #{ERROR_LEVEL_NAMES.join(", ")}.")
       end
     end
 
@@ -73,11 +113,15 @@ module Anodator
     end
 
     def level_expression
-      if @level == LEVEL_ERROR
-        return "ERROR"
-      elsif @level == LEVEL_WARNING
-        return "WARNING"
+      return Rule.level_expression(@level)
+    end
+
+    def self.level_expression(level)
+      if ERROR_LEVELS.values.include?(level)
+        return ERROR_LEVEL_NAMES[ERROR_LEVELS.index(level)]
       end
+
+      return nil
     end
 
     def to_s

data/lib/anodator/utils.rb

@@ -209,14 +209,11 @@ module Anodator
         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
+        if Rule::ERROR_LEVEL_NAMES.values.include?(row[5])
+          level = Rule::ERROR_LEVELS[Rule::ERROR_LEVEL_NAMES.index(row[5])]
+        else
+          raise "Unknown error type '#{row[5]}'"
+        end
         message = Message.new(row[6])
 
         rule_set <<

data/spec/anodator/check_result_spec.rb

@@ -36,7 +36,7 @@ describe CheckResult, ".new" do
   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)
+        CheckResult.new(["1", "2"], "An error occured for 1 and 2 values.", Rule::ERROR_LEVELS[:error])
       }
     end
 
@@ -58,7 +58,7 @@ describe CheckResult, ".new" do
       end
 
       it "#level should be set" do
-        @check_result.level.should == Rule::LEVEL_ERROR
+        @check_result.level.should == Rule::ERROR_LEVELS[:error]
       end
     end
   end
@@ -67,7 +67,7 @@ end
 describe CheckResult, "#error?" do
   context "when level is error" do
     before(:each) do
-      @check_result = CheckResult.new("1", "message", Rule::LEVEL_ERROR)
+      @check_result = CheckResult.new("1", "message", Rule::ERROR_LEVELS[:error])
     end
 
     it { @check_result.should be_error }
@@ -75,7 +75,7 @@ describe CheckResult, "#error?" do
 
   context "when level is warning" do
     before(:each) do
-      @check_result = CheckResult.new("1", "message", Rule::LEVEL_WARNING)
+      @check_result = CheckResult.new("1", "message", Rule::ERROR_LEVELS[:warning])
     end
 
     it { @check_result.should_not be_error }
@@ -85,7 +85,7 @@ end
 describe CheckResult, "#warning?" do
   context "when level is error" do
     before(:each) do
-      @check_result = CheckResult.new("1", "message", Rule::LEVEL_ERROR)
+      @check_result = CheckResult.new("1", "message", Rule::ERROR_LEVELS[:error])
     end
 
     it { @check_result.should_not be_warning }
@@ -93,7 +93,7 @@ describe CheckResult, "#warning?" do
 
   context "when level is warning" do
     before(:each) do
-      @check_result = CheckResult.new("1", "message", Rule::LEVEL_WARNING)
+      @check_result = CheckResult.new("1", "message", Rule::ERROR_LEVELS[:warning])
     end
 
     it { @check_result.should be_warning }

data/spec/anodator/output_spec_spec.rb

@@ -203,7 +203,7 @@ describe OutputSpec, "#generate" do
     @rule_set << Rule.new("3",
                           Message.new("[[3::name]] Cannot be blank"),
                           Validator::PresenceValidator.new("3"),
-                          nil, Rule::LEVEL_WARNING)
+                          nil, Rule::ERROR_LEVELS[:warning])
     @rule_set << Rule.new(["3", "4"],
                           Message.new("[[4::name]] Must be 'M' or 'F'"),
                           Validator::InclusionValidator.new("4",
@@ -237,10 +237,10 @@ describe OutputSpec, "#generate" do
       it "should generate error list datas" do
         @output_spec.generate(@input_spec, @rule_set.results).should ==
           [
-           ["", "", "", "", "1", "first name", "first name Cannot be blank", Rule::LEVEL_ERROR.to_s],
-           ["", "", "", "", "2", "family name", "family name Cannot be blank", Rule::LEVEL_ERROR.to_s],
-           ["", "", "", "", "3", "nickname", "nickname Cannot be blank", Rule::LEVEL_WARNING.to_s],
-           ["", "", "", "", "3 4", "nickname sex", "sex Must be 'M' or 'F'", Rule::LEVEL_ERROR.to_s],
+           ["", "", "", "", "1", "first name", "first name Cannot be blank", Rule::ERROR_LEVELS[:error].to_s],
+           ["", "", "", "", "2", "family name", "family name Cannot be blank", Rule::ERROR_LEVELS[:error].to_s],
+           ["", "", "", "", "3", "nickname", "nickname Cannot be blank", Rule::ERROR_LEVELS[:warning].to_s],
+           ["", "", "", "", "3 4", "nickname sex", "sex Must be 'M' or 'F'", Rule::ERROR_LEVELS[:error].to_s],
           ]
       end
     end

data/spec/anodator/rule_set_spec.rb

@@ -53,7 +53,7 @@ describe RuleSet, "after generated" do
       @rule_set.add_rule(Rule.new("phone",
                                   Message.new("[[phone::name]] is invalid format."),
                                   Validator::FormatValidator.new("phone", :format => /^\d+-\d+-\d+$/),
-                                  Validator::PresenceValidator.new("phone"), Rule::LEVEL_WARNING))
+                                  Validator::PresenceValidator.new("phone"), Rule::ERROR_LEVELS[:warning]))
       # mail address
       @rule_set.add_rule(Rule.new("4",
                                   Message.new("[[4:name]] is invalid format."),
@@ -87,7 +87,7 @@ describe RuleSet, "after generated" do
       @rule_set << Rule.new("phone",
                             Message.new("[[phone::name]] is invalid format."),
                             Validator::FormatValidator.new("phone", :format => /^\d+-\d+-\d+$/),
-                            Validator::PresenceValidator.new("phone"), Rule::LEVEL_WARNING)
+                            Validator::PresenceValidator.new("phone"), Rule::ERROR_LEVELS[:warning])
       # mail address
       @rule_set << Rule.new("4",
                             Message.new("[[4::name]] is invalid format."),
@@ -121,7 +121,7 @@ describe RuleSet, "after generated" do
       @rule_set << Rule.new("phone",
                             Message.new("[[phone::name]] is invalid format."),
                             Validator::FormatValidator.new("phone", :format => /^\d+-\d+-\d+$/),
-                            Validator::PresenceValidator.new("phone"), Rule::LEVEL_WARNING)
+                            Validator::PresenceValidator.new("phone"), Rule::ERROR_LEVELS[:warning])
       # mail address
       @rule_set << Rule.new("4",
                             Message.new("[[4::name]] is invalid format."),
@@ -165,7 +165,7 @@ describe RuleSet, "after generated" do
       @rule_set << Rule.new("phone",
                             Message.new("[[phone::name]] is invalid format.([[phone::value]])"),
                             Validator::FormatValidator.new("phone", :format => /^\d+-\d+-\d+$/),
-                            Validator::PresenceValidator.new("phone"), Rule::LEVEL_WARNING)
+                            Validator::PresenceValidator.new("phone"), Rule::ERROR_LEVELS[:warning])
       # mail address
       @rule_set << Rule.new("4",
                             Message.new("[[4::name]] is invalid format.([[4::value]])"),

data/spec/anodator/rule_spec.rb

@@ -67,8 +67,8 @@ describe Rule, "#new" do
         @rule.prerequisite.should be_nil
       end
 
-      it "#level should equal by default(LEVEL_ERROR)" do
-        @rule.level.should == Rule::LEVEL_ERROR
+      it "#level should equal by default(ERROR_LEVELS[:error])" do
+        @rule.level.should == Rule::ERROR_LEVELS[:error]
       end
     end
   end
@@ -81,7 +81,7 @@ describe Rule, "#new" do
         @message = Message.new("'[[1::name]]' and '[[2::name]]' cannot be blank")
         @validator = Validator::ComplexValidator.new(:validators => [v1, v2])
         @prerequisite = Validator::BlankValidator.new("3")
-        Rule.new(["1", "2"], @message, @validator, @prerequisite, Rule::LEVEL_WARNING)
+        Rule.new(["1", "2"], @message, @validator, @prerequisite, Rule::ERROR_LEVELS[:warning])
       }
     end
 
@@ -111,7 +111,7 @@ describe Rule, "#new" do
       end
 
       it "#level should equal by initialize" do
-        @rule.level.should == Rule::LEVEL_WARNING
+        @rule.level.should == Rule::ERROR_LEVELS[:warning]
       end
     end
   end
@@ -167,3 +167,35 @@ describe Rule, "#check" do
     it { @rule.check.should be_nil }
   end
 end
+
+describe Rule, ".add_error_level" do
+  context "when new valid error level" do
+    before(:each) do
+      @proc = lambda {
+        Rule.add_error_level(3, :fatal, "FATAL")
+      }
+    end
+
+    after(:each) do
+      Rule.remove_error_level(:fatal)
+    end
+
+    it "should not raise error" do
+      lambda {
+        @proc.call
+      }.should_not raise_error
+    end
+
+    it "should 3 error levels" do
+      lambda {
+        @proc.call
+      }.should change(Rule::ERROR_LEVELS, :size).from(2).to(3)
+    end
+
+    it "should 3 error level names" do
+      lambda {
+        @proc.call
+      }.should change(Rule::ERROR_LEVEL_NAMES, :size).from(2).to(3)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: anodator
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
+  - 2
   segments_generated: true
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Tetsuhisa MAKINO