ippy04-remarkable_mongo 0.1.3

data/locales/en.yml

@@ -0,0 +1,135 @@
+en:
+  remarkable:
+    mongo_mapper:
+      describe:
+        each: "{{key}} is {{value}}"
+        prepend: "when "
+        connector: " and "
+      expectations:
+        allow_nil: "{{subject_name}} to {{not}}allow nil values for {{attribute}}"
+        allow_blank: "{{subject_name}} to {{not}}allow blank values for {{attribute}}"
+      optionals:
+        allow_nil:
+          positive: "allowing nil values"
+          negative: "not allowing nil values"
+        allow_blank:
+          positive: "allowing blank values"
+          negative: "not allowing blank values"
+      
+      allow_values_for:
+        description: "allow {{in}} as values for {{attributes}}"
+        expectations:
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+          
+      association:
+        many: have many
+        belongs_to: belong to
+        description: "{{type}} {{associations}}"
+        expectations:
+          association_exists: "{{subject_name}} records {{type}} {{association}}, but the association does not exist"
+          type_matches: "{{subject_name}} records {{type}} {{association}}, got {{subject_name}} records {{actual_type}} {{association}}"
+          klass_exists: "{{subject_name}} records {{type}} {{association}}, but the association class does not exist"
+          options_match: "{{subject_name}} records {{type}} {{association}} with options {{options}}, got {{actual}}"
+          
+      have_key:
+        description: "have key(s) {{attributes}} with type {{type}}"
+        expectations:
+          has_key: "{{subject_name}} to have key named {{attribute}} with type {{type}}"
+          
+      validate_acceptance_of:
+        description: "require {{attributes}} to be accepted"
+        expectations:
+          requires_acceptance: "{{subject_name}} to be invalid if {{attribute}} is not accepted"
+          accept_is_valid: "{{subject_name}} to be valid when {{attribute}} is accepted with value {{accept}}"
+        optionals:
+          accept:
+            positive: "with value {{inspect}}"
+
+      validate_associated:
+        description: "require associated {{associations}} to be valid"
+        expectations:
+          is_valid: "{{subject_name}} to be invalid when {{association}} is invalid"
+          
+      validate_confirmation_of:
+        description: "require {{attributes}} to be confirmed"
+        expectations:
+          responds_to_confirmation: "{{subject_name}} instance responds to {{attribute}}_confirmation"
+          confirms: "{{subject_name}} to be valid only when {{attribute}} is confirmed"
+          
+      validate_exclusion_of:
+        description: "ensure exclusion of {{attributes}} in {{in}}"
+        expectations:
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+          is_invalid: "{{subject_name}} to be invalid when {{attribute}} is set to {{value}}"
+
+      validate_inclusion_of:
+        description: "ensure inclusion of {{attributes}} in {{in}}"
+        expectations:
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+          is_invalid: "{{subject_name}} to be invalid when {{attribute}} is set to {{value}}"
+
+      validate_length_of:
+        description: "ensure length of {{attributes}}"
+        expectations:
+          less_than_min_length: "{{subject_name}} to be invalid when {{attribute}} length is less than {{minimum}} characters"
+          exactly_min_length: "{{subject_name}} to be valid when {{attribute}} length is {{minimum}} characters"
+          more_than_max_length: "{{subject_name}} to be invalid when {{attribute}} length is more than {{maximum}} characters"
+          exactly_max_length: "{{subject_name}} to be valid when {{attribute}} length is {{maximum}} characters"
+        optionals:
+          within:
+            positive: "is within {{inspect}} characters"
+          maximum:
+            positive: "is maximum {{inspect}} characters"
+          minimum:
+            positive: "is minimum {{inspect}} characters"
+          is:
+            positive: "is equal to {{inspect}} characters"
+          with_kind_of:
+            positive: "with kind of {{value}}"
+
+      validate_numericality_of:
+        description: "ensure numericality of {{attributes}}"
+        expectations:
+          only_numeric_values: "{{subject_name}} to allow only numeric values for {{attribute}}"
+          only_integer: "{{subject_name}} to {{not}}allow only integer values for {{attribute}}"
+          only_even: "{{subject_name}} to allow only even values for {{attribute}}"
+          only_odd: "{{subject_name}} to allow only odd values for {{attribute}}"
+          equals_to: "{{subject_name}} to be valid only when {{attribute}} is equal to {{count}}"
+          more_than_maximum: "{{subject_name}} to be invalid when {{attribute}} is greater than {{count}}"
+          less_than_minimum: "{{subject_name}} to be invalid when {{attribute}} is less than {{count}}"
+        optionals:
+          only_integer:
+            positive: "allowing only integer values"
+          odd:
+            positive: "allowing only odd values"
+          even:
+            positive: "allowing only even values"
+          equal_to:
+            positive: "is equal to {{inspect}}"
+          less_than:
+            positive: "is less than {{inspect}}"
+          greater_than:
+            positive: "is greater than {{inspect}}"
+          less_than_or_equal_to:
+            positive: "is less than or equal to {{inspect}}"
+          greater_than_or_equal_to:
+            positive: "is greater than or equal to {{inspect}}"
+
+      validate_presence_of:
+        description: "require {{attributes}} to be set"
+        expectations:
+          allow_nil: "{{subject_name}} to require {{attribute}} to be set"
+          
+      validate_uniqueness_of:
+        description: "require unique values for {{attributes}}"
+        expectations:
+          responds_to_scope: "{{subject_name}} instance responds to {{method}}"
+          is_unique: "{{subject_name}} to require unique values for {{attribute}}"
+          case_sensitive: "{{subject_name}} to {{not}}be case sensitive on {{attribute}} validation"
+          valid_with_new_scope: "{{subject_name}} to be valid when {{attribute}} scope ({{method}}) change"
+        optionals:
+          scope:
+            positive: "scoped to {{sentence}}"
+          case_sensitive:
+            positive: "case sensitive"
+            negative: "case insensitive"

data/remarkable_mongo.gemspec

@@ -0,0 +1,79 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{remarkable_mongo}
+  s.version = "0.1.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Nicolas M\303\251rouze"]
+  s.date = %q{2010-01-11}
+  s.email = %q{nicolas.merouze@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "lib/remarkable/mongo_mapper.rb",
+     "lib/remarkable/mongo_mapper/base.rb",
+     "lib/remarkable/mongo_mapper/describe.rb",
+     "lib/remarkable/mongo_mapper/human_names.rb",
+     "lib/remarkable/mongo_mapper/matchers/allow_values_for_matcher.rb",
+     "lib/remarkable/mongo_mapper/matchers/association_matcher.rb",
+     "lib/remarkable/mongo_mapper/matchers/have_key_matcher.rb",
+     "lib/remarkable/mongo_mapper/matchers/validate_confirmation_of_matcher.rb",
+     "lib/remarkable/mongo_mapper/matchers/validate_length_of_matcher.rb",
+     "lib/remarkable/mongo_mapper/matchers/validate_presence_of_matcher.rb",
+     "locales/en.yml",
+     "spec/matchers/allow_values_for_matcher_spec.rb",
+     "spec/matchers/association_matcher_spec.rb",
+     "spec/matchers/have_key_matcher_spec.rb",
+     "spec/matchers/validate_confirmation_of_matcher_spec.rb",
+     "spec/matchers/validate_length_of_matcher_spec.rb",
+     "spec/matchers/validate_presence_of_matcher_spec.rb",
+     "spec/model_builder.rb",
+     "spec/models.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/nmerouze/remarkable_mongo}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Remarkable Matchers for MongoDB ORMs}
+  s.test_files = [
+    "spec/matchers/allow_values_for_matcher_spec.rb",
+     "spec/matchers/association_matcher_spec.rb",
+     "spec/matchers/have_key_matcher_spec.rb",
+     "spec/matchers/validate_confirmation_of_matcher_spec.rb",
+     "spec/matchers/validate_length_of_matcher_spec.rb",
+     "spec/matchers/validate_presence_of_matcher_spec.rb",
+     "spec/model_builder.rb",
+     "spec/models.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<remarkable>, ["~> 3.1.8"])
+      s.add_runtime_dependency(%q<mongo_mapper>, ["~> 0.6.1"])
+    else
+      s.add_dependency(%q<remarkable>, ["~> 3.1.8"])
+      s.add_dependency(%q<mongo_mapper>, ["~> 0.6.1"])
+    end
+  else
+    s.add_dependency(%q<remarkable>, ["~> 3.1.8"])
+    s.add_dependency(%q<mongo_mapper>, ["~> 0.6.1"])
+  end
+end
+

data/spec/matchers/allow_values_for_matcher_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'allow_values_for' do
+  include ModelBuilder
+
+  # Defines a model, create a validation and returns a raw matcher
+  def define_and_validate(options={})
+    @model = define_model :product do
+      include MongoMapper::Document
+      
+      key :title, String
+      key :category, String
+      
+      validates_format_of :title, options
+    end
+
+    allow_values_for(:title)
+  end
+
+  describe 'messages' do
+    before(:each){ @matcher = define_and_validate(:with => /X|Y|Z/) }
+
+    it 'should contain a description' do
+      @matcher = allow_values_for(:title, "X", "Y", "Z")
+      @matcher.description.should == 'allow "X", "Y", and "Z" as values for title'
+    end
+
+    it 'should set is_valid? message' do
+      @matcher.in("A").matches?(subject)
+      @matcher.failure_message.should == 'Expected Product to be valid when title is set to "A"'
+    end
+
+    it 'should set allow_nil? message' do
+      @matcher.allow_nil.matches?(subject)
+      @matcher.failure_message.should == 'Expected Product to allow nil values for title'
+    end
+
+    it 'should set allow_blank? message' do
+      @matcher.allow_blank.matches?(subject)
+      @matcher.failure_message.should == 'Expected Product to allow blank values for title'
+    end
+  end
+
+  describe 'matchers' do
+    it { should define_and_validate(:with => /X|Y|Z/).in('X', 'Y', 'Z') }
+    it { should_not define_and_validate(:with => /X|Y|Z/).in('A') }
+  
+    it { should define_and_validate(:with => /X|Y|Z/, :message => 'valid').in('X', 'Y', 'Z').message('valid') }
+  
+    create_optional_boolean_specs(:allow_nil, self, :with => /X|Y|Z/)
+    create_optional_boolean_specs(:allow_blank, self, :with => /X|Y|Z/)
+  end
+  
+  describe 'macros' do
+    before(:each){ define_and_validate(:with => /X|Y|Z/) }
+    
+    should_allow_values_for :title, 'X'
+    should_not_allow_values_for :title, 'A'
+  end
+  
+  describe 'failures' do
+    it "should fail if any of the values are valid on invalid cases" do
+      define_and_validate(:with => /X|Y|Z/)
+      
+      lambda {
+        should_not allow_values_for(:title, 'A', 'X', 'B')
+      }.should raise_error(Spec::Expectations::ExpectationNotMetError, /Did not expect Product to be valid/)
+    end
+  end
+end
+

data/spec/matchers/association_matcher_spec.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'association_matcher' do
+  subject do
+    Article.new
+  end
+  
+  describe 'have_many' do
+
+    describe 'messages' do
+      it 'should contain a description' do
+        matcher = have_many(:comments)
+        matcher.description.should == 'have many comments'
+      end
+
+      it 'should set association_exists? message' do
+        matcher = have_many(:whatever)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records have many whatever, but the association does not exist'
+      end
+
+      it 'should set type_matches? message' do
+        matcher = belong_to(:comments)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records belong to comments, got Article records have many comments'
+      end
+      
+      it 'should set klass_exists? message' do
+        matcher = have_many(:unknowns)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records have many unknowns, but the association class does not exist'
+      end
+      
+      it 'should set options_matches? message when :class_name is given' do
+        matcher = have_many(:ratings, :class_name => 'Rating')
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records have many ratings with options {:class_name=>"Rating"}, got {:class_name=>"Rate"}'
+      end
+      
+      it 'should set options_matches? message when :polymorphic is given' do
+        matcher = have_many(:assets, :polymorphic => true)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records have many assets with options {:polymorphic=>"true"}, got {:polymorphic=>""}'
+      end
+    end
+    
+    describe 'matchers' do
+      it { should have_many(:comments) }
+      it { should_not belong_to(:comment) }
+    end
+    
+    describe 'macros' do
+      should_have_many :comments
+      should_not_belong_to :comment
+    end
+
+  end
+  
+  describe 'belong_to' do
+
+    describe 'messages' do
+      it 'should contain a description' do
+        matcher = belong_to(:user)
+        matcher.description.should == 'belong to user'
+      end
+
+      it 'should set association_exists? message' do
+        matcher = belong_to(:whatever)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records belong to whatever, but the association does not exist'
+      end
+      
+      it 'should set type_matches? message' do
+        matcher = have_many(:user)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records have many user, got Article records belong to user'
+      end
+      
+      it 'should set klass_exists? message' do
+        matcher = belong_to(:unknown)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records belong to unknown, but the association class does not exist'
+      end
+      
+      it 'should set options_matches? message when :class_name is given' do
+        matcher = belong_to(:site, :class_name => 'Website')
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records belong to site with options {:class_name=>"Website"}, got {:class_name=>"Site"}'
+      end
+    end
+    
+    describe 'matchers' do
+      it { should belong_to(:user) }
+      it { should_not have_many(:users) }
+    end
+    
+    describe 'macros' do
+      should_belong_to :user
+      should_not_have_many :users
+    end
+
+  end
+
+end

data/spec/matchers/have_key_matcher_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'have_key' do
+  subject do
+    Article.new
+  end
+  
+  describe 'messages' do
+
+    it 'should contain a description' do
+      matcher = have_key(:title, String)
+      matcher.description.should == 'have key(s) title with type String'
+    end
+
+    it 'should set has_key? message' do
+      matcher = have_key(:owner, String)
+      matcher.matches?(subject)
+      matcher.failure_message.should == 'Expected Article to have key named owner with type String'
+    end
+
+  end
+  
+  describe 'matchers' do
+    it { should have_key(:title, String) }
+    it { should have_keys(:title, :body, String) }
+  end
+
+  describe 'macros' do
+    should_have_key :title, String
+    should_have_keys :title, :body, String
+  end
+end

data/spec/matchers/validate_confirmation_of_matcher_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'validate_confirmation_of' do
+  include ModelBuilder
+
+  # Defines a model, create a validation and returns a raw matcher
+  def define_and_validate(options={})
+    @model = define_model :person do
+      include MongoMapper::Document
+      
+      key :name, String
+      key :email, String
+      key :age, String
+      
+      validates_confirmation_of :name, :email, options
+    end
+
+    validate_confirmation_of(:name, :email)
+  end
+
+  describe 'messages' do
+    before(:each){ @matcher = define_and_validate }
+
+    it 'should contain a description' do
+      @matcher.description.should == 'require name and email to be confirmed'
+    end
+
+    it 'should set responds_to_confirmation? message' do
+      @matcher = validate_confirmation_of(:age)
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected Person instance responds to age_confirmation'
+    end
+
+    it 'should set confirms? message' do
+      @model.instance_eval{ def age_confirmation=(*args); end }
+      @matcher = validate_confirmation_of(:age)
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected Person to be valid only when age is confirmed'
+    end
+
+  end
+
+  describe 'matchers' do
+
+    describe 'without options' do
+      before(:each){ define_and_validate }
+
+      it { should validate_confirmation_of(:name) }
+      it { should validate_confirmation_of(:name, :email) }
+      it { should_not validate_confirmation_of(:name, :age) }
+    end
+
+    create_message_specs(self)
+  end
+
+  describe 'macros' do
+    before(:each){ define_and_validate }
+
+    should_validate_confirmation_of :name
+    should_validate_confirmation_of :name, :email
+    should_not_validate_confirmation_of :name, :age
+  end
+
+end