anodator 0.0.5 → 1.0.0.pre1

data/spec/anodator/message_spec.rb

@@ -1,112 +0,0 @@
-require "spec_helper"
-
-# Anodator::Message
-require "anodator/message"
-require "anodator/input_spec"
-
-include Anodator
-
-describe Message, ".new" do
-  context "with no parameters" do
-    it "should raise ArgumentError" do
-      lambda {
-        Message.new
-      }.should raise_error ArgumentError
-    end
-  end
-
-  context "with simple template_message" do
-    before(:each) do
-      @new_proc = lambda {
-        Message.new("An error occured!!")
-      }
-    end
-
-    it "should not raise error" do
-      @new_proc.should_not raise_error
-    end
-
-    it "#template should be provided string" do
-      @message = @new_proc.call
-      @message.template.should == "An error occured!!"
-    end
-  end
-
-  context "with template_message include place holder" do
-    before(:each) do
-      @template = "An error occured [[1::name]]([[1::number]]) must not be [[1::value]]"
-      @new_proc = lambda {
-        Message.new(@template)
-      }
-    end
-
-    it "should not raise error" do
-      @new_proc.should_not raise_error
-    end
-
-    it "#template should be provided string" do
-      @message = @new_proc.call
-      @message.template.should == @template
-    end
-  end
-end
-
-describe Message, "#expand" do
-  before(:each) do
-    # create input spec and data source
-    @input_spec = InputSpec.new([
-                                 { :number => "1", :name => "item_1" },
-                                 { :number => "2", :name => "item_2" },
-                                 { :number => "3", :name => "item_3" },
-                                 { :number => "4", :name => "item_4" },
-                                 { :number => "5", :name => "item_5" },
-                                ])
-    @values = %W(1 2 3 4 5)
-    @input_spec.source = @values
-  end
-
-  context "when message is valid" do
-    before(:each) do
-      @template = "An error occured [[1::name]]([[1::number]]) must not be '[[1::value]]'"
-      @message = Message.new(@template)
-      @proc = lambda { @message.expand(@input_spec) }
-    end
-
-    it "should not raise error" do
-      @proc.should_not raise_error
-    end
-
-    it "should equal replacement values" do
-      @proc.call.should ==
-        "An error occured item_1(1) must not be '1'"
-    end
-  end
-
-  context "when message's place holder contain unknown field" do
-    context "include unknown target_expression" do
-      before(:each) do
-        @template = "An error occured [[1::name]]([[1::number]]) must not be [[289::value]]"
-        @message = Message.new(@template)
-        @proc = lambda { @message.expand(@input_spec) }
-      end
-
-      it "should raise UnknownTargetExpressionError" do
-        @proc.should raise_error UnknownTargetExpressionError
-      end
-    end
-  end
-
-  context "when message's place holder contain unknown field" do
-    context "include unknown attribute" do
-      before(:each) do
-        @template = "An error occured [[1::name]]([[1::number]]) must not be [[1::values]]"
-        @message = Message.new(@template)
-        @proc = lambda { @message.expand(@input_spec) }
-      end
-
-      it "should raise UnknownMessageAttributeError" do
-        @proc.should raise_error UnknownMessageAttributeError
-      end
-    end
-  end
-end

data/spec/anodator/output_spec_spec.rb

@@ -1,355 +0,0 @@
-require "spec_helper"
-
-# Anodator::OutputSpec
-require "anodator/output_spec"
-
-include Anodator
-
-describe OutputSpec, ".new" do
-  context "with no paramerters" do
-    before(:each) do
-      @new_proc = lambda {
-        OutputSpec.new
-      }
-    end
-
-    it "should not raise error" do
-      @new_proc.should_not raise_error
-    end
-
-    context "after generated" do
-      before(:each) do
-        @output_spec = @new_proc.call
-      end
-
-      it "#items should be empty" do
-        @output_spec.items.should be_empty
-      end
-
-      it "#target should be OutputSpec::TARGET_ERROR by default" do
-        @output_spec.target.should == OutputSpec::TARGET_ERROR
-      end
-
-      it "#include_no_error should be false by default" do
-        @output_spec.include_no_error.should be_false
-      end
-    end
-  end
-
-  context "with several error items parameter" do
-    before(:each) do
-      @new_proc = lambda {
-        OutputSpec.new([
-                        :target_numbers,
-                        :target_names,
-                        :target_values,
-                        :error_message,
-                        :error_level,
-                       ])
-      }
-    end
-
-    it "should not raise error" do
-      @new_proc.should_not raise_error
-    end
-
-    context "after generated" do
-      before(:each) do
-        @output_spec = @new_proc.call
-      end
-
-      it "#items should not be empty" do
-        @output_spec.items.should_not be_empty
-      end
-
-      it "#target should be OutputSpec::TARGET_ERROR by default" do
-        @output_spec.target.should == OutputSpec::TARGET_ERROR
-      end
-
-      it "#include_no_error should be false by default" do
-        @output_spec.include_no_error.should be_false
-      end
-    end
-  end
-
-  context "with several input items parameter with error items" do
-    before(:each) do
-      @new_proc = lambda {
-        OutputSpec.new([
-                        "1",
-                        "2",
-                        "3",
-                        "name",
-                       ])
-      }
-    end
-
-    it "should not raise error" do
-      @new_proc.should_not raise_error
-    end
-
-    context "after generated" do
-      before(:each) do
-        @output_spec = @new_proc.call
-      end
-
-      it "#items should not be empty" do
-        @output_spec.items.should_not be_empty
-      end
-
-      it "#target should be OutputSpec::TARGET_ERROR by default" do
-        @output_spec.target.should == OutputSpec::TARGET_ERROR
-      end
-
-      it "#include_no_error should be false by default" do
-        @output_spec.include_no_error.should be_false
-      end
-    end
-  end
-
-  context "with items and :target option" do
-    before(:each) do
-      @new_proc = lambda {
-        OutputSpec.new([
-                        "1",
-                        "2",
-                        "3",
-                        "name",
-                       ],
-                       :target => OutputSpec::TARGET_DATA)
-      }
-    end
-
-    it "should not raise error" do
-      @new_proc.should_not raise_error
-    end
-
-    context "after generated" do
-      before(:each) do
-        @output_spec = @new_proc.call
-      end
-
-      it "#items should not be empty" do
-        @output_spec.items.should_not be_empty
-      end
-
-      it "#target should be OutputSpec::TARGET_DATA" do
-        @output_spec.target.should == OutputSpec::TARGET_DATA
-      end
-
-      it "#include_no_error should be false by default" do
-        @output_spec.include_no_error.should be_false
-      end
-    end
-  end
-
-  context "with items and :target option and :include_no_error option" do
-    before(:each) do
-      @new_proc = lambda {
-        OutputSpec.new([
-                        "1",
-                        "2",
-                        "3",
-                        "name",
-                        :target_numbers,
-                        :error_message,
-                        :error_level,
-                       ],
-                       :target => OutputSpec::TARGET_ERROR,
-                       :include_no_error => true)
-      }
-    end
-
-    it "should not raise error" do
-      @new_proc.should_not raise_error
-    end
-
-    context "after generated" do
-      before(:each) do
-        @output_spec = @new_proc.call
-      end
-
-      it "#items should not be empty" do
-        @output_spec.items.should_not be_empty
-      end
-
-      it "#target should be OutputSpec::TARGET_ERROR" do
-        @output_spec.target.should == OutputSpec::TARGET_ERROR
-      end
-
-      it "#include_no_error should be true" do
-        @output_spec.include_no_error.should be_true
-      end
-    end
-  end
-end
-
-describe OutputSpec, "#generate" do
-  before(:each) do
-    # preparation
-    @input_spec = InputSpec.new([
-                                 { :number => "1", :name => "first name" },
-                                 { :number => "2", :name => "family name" },
-                                 { :number => "3", :name => "nickname" },
-                                 { :number => "4", :name => "sex" },
-                                ])
-    @rule_set = RuleSet.new
-    @rule_set << Rule.new("1",
-                          Message.new("[[1::name]] Cannot be blank"),
-                          Validator::PresenceValidator.new("1"))
-    @rule_set << Rule.new("2",
-                          Message.new("[[2::name]] Cannot be blank"),
-                          Validator::PresenceValidator.new("2"))
-    @rule_set << Rule.new("3",
-                          Message.new("[[3::name]] Cannot be blank"),
-                          Validator::PresenceValidator.new("3"),
-                          nil, Rule::ERROR_LEVELS[:warning])
-    @rule_set << Rule.new(["3", "4"],
-                          Message.new("[[4::name]] Must be 'M' or 'F'"),
-                          Validator::InclusionValidator.new("4",
-                                                            :in => %W(M F)))
-    Validator::Base.values = @input_spec
-  end
-
-  context "when including errors" do
-    before(:each) do
-      @values = ["", "", "", ""]
-      @input_spec.source = @values
-      @rule_set.check_all
-    end
-
-    context "generate error list" do
-      before(:each) do
-        @output_spec = OutputSpec.new([
-                                       "1",
-                                       "2",
-                                       "nickname",
-                                       "4",
-                                       :target_numbers,
-                                       :target_names,
-                                       :error_message,
-                                       :error_level,
-                                      ],
-                                      :target => OutputSpec::TARGET_ERROR,
-                                      :include_no_error => true)
-      end
-
-      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::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
-
-    context "generate data list" do
-      before(:each) do
-        @output_spec = OutputSpec.new([
-                                       "1",
-                                       "2",
-                                       "nickname",
-                                       "4",
-                                       :target_numbers,
-                                       :target_names,
-                                       :error_message,
-                                       :error_level,
-                                       :error_count,
-                                       :warning_count,
-                                       :error_and_warning_count,
-                                      ],
-                                      :target => OutputSpec::TARGET_DATA,
-                                      :include_no_error => true)
-      end
-
-      it "should generate list data" do
-        @output_spec.generate(@input_spec, @rule_set.results).should ==
-          [
-           ["", "", "", "", "", "", "", "", "3", "1", "4"],
-          ]
-      end
-    end
-  end
-
-  context "when including no errors" do
-    before(:each) do
-      @values = ["Tetsuhisa", "MAKINO", "makitetsu", "M"]
-      @input_spec.source = @values
-      @rule_set.check_all
-    end
-
-    context "generate error list include no error" do
-      before(:each) do
-        @output_spec = OutputSpec.new([
-                                       "1",
-                                       "2",
-                                       "nickname",
-                                       "4",
-                                       :target_numbers,
-                                       :target_names,
-                                       :error_message,
-                                       :error_level,
-                                      ],
-                                      :target => OutputSpec::TARGET_ERROR,
-                                      :include_no_error => true)
-      end
-
-      it "should generate one data" do
-        @output_spec.generate(@input_spec, @rule_set.results).should ==
-          [
-           ["Tetsuhisa", "MAKINO", "makitetsu", "M", "", "", "", ""]
-          ]
-      end
-    end
-
-    context "generate error list not include no error" do
-      before(:each) do
-        @output_spec = OutputSpec.new([
-                                       "1",
-                                       "2",
-                                       "nickname",
-                                       "4",
-                                       :target_numbers,
-                                       :target_names,
-                                       :error_message,
-                                       :error_level,
-                                      ],
-                                      :target => OutputSpec::TARGET_ERROR,
-                                      :include_no_error => false)
-      end
-
-      it "should be empty" do
-        @output_spec.generate(@input_spec, @rule_set.results).should be_empty
-      end
-    end
-
-    context "generate data list" do
-      before(:each) do
-        @output_spec = OutputSpec.new([
-                                       "1",
-                                       "2",
-                                       "nickname",
-                                       "4",
-                                       :target_numbers,
-                                       :target_names,
-                                       :error_message,
-                                       :error_level,
-                                       :error_count,
-                                       :warning_count,
-                                       :error_and_warning_count,
-                                      ],
-                                      :target => OutputSpec::TARGET_DATA,
-                                      :include_no_error => true)
-      end
-
-      it "should not raise error" do
-        @output_spec.generate(@input_spec, @rule_set.results).should ==
-          [
-           ["Tetsuhisa", "MAKINO", "makitetsu", "M", "", "", "", "", "0", "0", "0"],
-          ]
-      end
-    end
-  end
-end

data/spec/anodator/rule_set_spec.rb

@@ -1,190 +0,0 @@
-require "spec_helper"
-
-# Anodator::RuleSet
-require "anodator/rule_set"
-
-include Anodator
-
-describe RuleSet, ".new" do
-  context "with no parameters" do
-    it "should not raise error" do
-      lambda {
-        RuleSet.new
-      }.should_not raise_error
-    end
-  end
-end
-
-describe RuleSet, "after generated" do
-  before(:each) do
-    # preparation
-    @input_spec = InputSpec.new([
-                                 { :number => "1", :name => "first name"},
-                                 { :number => "2", :name => "family name"},
-                                 { :number => "3", :name => "phone"},
-                                 { :number => "4", :name => "mail address"},
-                                 { :number => "5", :name => "sex"},
-                                 { :number => "6", :name => "age"},
-                                ])
-    @records =
-      [
-       [ "Tetsuhisa" , ""         , "0000-0000-0000"  , "tim.makino@gmail.com" , "M"    , "31" ],
-       [ "Takashi"   , "Nakajima" , "0000-00-00-0001" , "nakajima@example@com" , "Male" , "28.4" ],
-      ]
-
-    ### Rules
-    @rule_set = RuleSet.new
-
-    ### set datas
-    Validator::Base.values = @input_spec
-  end
-
-  describe RuleSet, "#add_rule" do
-    before(:each) do
-      # first name
-      @rule_set.add_rule(Rule.new("1",
-                                  Message.new("[[1::name]] cannot be blank."),
-                                  Validator::PresenceValidator.new("1")))
-      # family name
-      @rule_set.add_rule(Rule.new("2",
-                                  Message.new("[[2::name]] cannot be blank."),
-                                  Validator::PresenceValidator.new("2")))
-      # phone
-      @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::ERROR_LEVELS[:warning]))
-      # mail address
-      @rule_set.add_rule(Rule.new("4",
-                                  Message.new("[[4:name]] is invalid format."),
-                                  Validator::FormatValidator.new("4", :format => /^[^@]+@[^@]+$/, :allow_blank => true)))
-      # sex
-      @rule_set.add_rule(Rule.new("5",
-                                  Message.new("[[5::name]] must be M/F/Man/Woman."),
-                                  Validator::InclusionValidator.new("5", :in => %W(M F Man Woman))))
-      # age
-      @rule_set.add_rule(Rule.new("age",
-                                  Message.new("[[age::name]] must be integer."),
-                                  Validator::NumericValidator.new("age", :only_integer => true)))
-    end
-
-    it "should have all rules" do
-      @rule_set.instance_eval("@rules.count").should == 6
-    end
-  end
-
-  describe RuleSet, "#<<" do
-    before(:each) do
-      # first name
-      @rule_set << Rule.new("1",
-                            Message.new("[[1::name]] cannot be blank."),
-                            Validator::PresenceValidator.new("1"))
-      # family name
-      @rule_set << Rule.new("2",
-                            Message.new("[[2::name]] cannot be blank."),
-                            Validator::PresenceValidator.new("2"))
-      # phone
-      @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::ERROR_LEVELS[:warning])
-      # mail address
-      @rule_set << Rule.new("4",
-                            Message.new("[[4::name]] is invalid format."),
-                            Validator::FormatValidator.new("4", :format => /^[^@]+@[^@]+$/, :allow_blank => true))
-      # sex
-      @rule_set << Rule.new("5",
-                            Message.new("[[5::name]] must be M/F/Man/Woman."),
-                            Validator::InclusionValidator.new("5", :in => %W(M F Man Woman)))
-      # age
-      @rule_set << Rule.new("age",
-                            Message.new("[[age::name]] must be integer."),
-                            Validator::NumericValidator.new("age", :only_integer => true))
-    end
-
-    it "should have all rules" do
-      @rule_set.instance_eval("@rules.count").should == 6
-    end
-  end
-
-  describe RuleSet, "#check_all" do
-    before(:each) do
-      # first name
-      @rule_set << Rule.new("1",
-                            Message.new("[[1::name]] cannot be blank."),
-                            Validator::PresenceValidator.new("1"))
-      # family name
-      @rule_set << Rule.new("2",
-                            Message.new("[[2::name]] cannot be blank."),
-                            Validator::PresenceValidator.new("2"))
-      # phone
-      @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::ERROR_LEVELS[:warning])
-      # mail address
-      @rule_set << Rule.new("4",
-                            Message.new("[[4::name]] is invalid format."),
-                            Validator::FormatValidator.new("4", :format => /^[^@]+@[^@]+$/, :allow_blank => true))
-      # sex
-      @rule_set << Rule.new("5",
-                            Message.new("[[5::name]] must be M/F/Man/Woman."),
-                            Validator::InclusionValidator.new("5", :in => %W(M F Man Woman)))
-      # age
-      @rule_set << Rule.new("age",
-                            Message.new("[[age::name]] must be integer."),
-                            Validator::NumericValidator.new("age", :only_integer => true))
-
-      @proc = lambda {
-        @input_spec.source = @records.first
-        @rule_set.check_all
-      }
-    end
-
-    it "should not raise error" do
-      @proc.should_not raise_error
-    end
-
-    it "should have results" do
-      @proc.call
-      @rule_set.instance_eval("@results.count").should_not be_zero
-    end
-  end
-
-  describe RuleSet, "#results" do
-    before(:each) do
-      # first name
-      @rule_set << Rule.new("1",
-                            Message.new("[[1::name]] cannot be blank."),
-                            Validator::PresenceValidator.new("1"))
-      # family name
-      @rule_set << Rule.new("2",
-                            Message.new("[[2::name]] cannot be blank."),
-                            Validator::PresenceValidator.new("2"))
-      # phone
-      @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::ERROR_LEVELS[:warning])
-      # mail address
-      @rule_set << Rule.new("4",
-                            Message.new("[[4::name]] is invalid format.([[4::value]])"),
-                            Validator::FormatValidator.new("4", :format => /^[^@]+@[^@]+$/, :allow_blank => true))
-      # sex
-      @rule_set << Rule.new("5",
-                            Message.new("[[5::name]] must be M/F/Man/Woman.([[5::value]])"),
-                            Validator::InclusionValidator.new("5", :in => %W(M F Man Woman)))
-      # age
-      @rule_set << Rule.new("age",
-                            Message.new("[[age::name]] must be integer.([[age::value]])"),
-                            Validator::NumericValidator.new("age", :only_integer => true))
-
-      @input_spec.source = @records.last
-      @rule_set.check_all
-    end
-
-    it "should have results count 4" do
-      @rule_set.results.count.should == 4
-    end
-  end
-end