ippy04-remarkable_mongo 0.1.3

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+pkg/*

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Nicolas Mérouze
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,23 @@
+# Remarkable MongoMapper
+
+Remarkable matchers for [MongoMapper](http://github.com/jnunemaker/mongomapper).
+
+## Matchers
+
+<pre><code>it { should have_key(:name, String) }
+it { should have_keys(:name, :phone_number, String) }
+it { should validate_presence_of(:name, :phone_number, :message => "not there!") }
+it { should belong_to(:user, :class_name => 'Person') }
+it { should have_many(:users, :class_name => 'Person', :polymorphic => true) }</code></pre>
+
+## TODO
+
+* Finish validate_length_of
+
+## Contributions
+
+It is far from complete! It'd be very helpful to have some help.
+
+## Contributors
+
+* Nicolas Mérouze

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'rake'
+require 'spec/rake/spectask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ippy04-remarkable_mongo"
+    gem.summary = %Q{Remarkable Matchers for MongoDB ORMs}
+    gem.email = "nicolas.merouze@gmail.com"
+    gem.homepage = "http://github.com/ippy04/remarkable_mongo"
+    gem.authors = ["Nicolas Merouze", "Justin Ip"]
+    
+    gem.add_dependency('remarkable',  '~> 3.1.8')
+    gem.add_dependency('mongo_mapper', '~> 0.7.0')
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc 'Run all the specs for the machinist plugin.'
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = false
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.3

data/lib/remarkable/mongo_mapper.rb

@@ -0,0 +1,30 @@
+# Load Remarkable
+unless Object.const_defined?('Remarkable')
+  begin
+    require 'remarkable'
+  rescue LoadError
+    require 'rubygems'
+    gem 'remarkable'
+    require 'remarkable'
+  end
+end
+ 
+# Add locale
+dir = File.dirname(__FILE__)
+Remarkable.add_locale File.join(dir, '..', '..', 'locales', 'en.yml')
+
+require File.join(dir, 'mongo_mapper', 'base')
+require File.join(dir, 'mongo_mapper', 'describe')
+# require File.join(dir, 'remarkable_mongomapper', 'human_names')
+
+# Add matchers
+Dir[File.join(dir, 'mongo_mapper', 'matchers', '*.rb')].each do |file|
+  require file
+end
+
+# Include Remarkable MongoMapper matcher in appropriate ExampleGroup
+if defined?(Spec::Rails)
+  Remarkable.include_matchers!(Remarkable::MongoMapper, Spec::Rails::Example::ModelExampleGroup)
+else
+  Remarkable.include_matchers!(Remarkable::MongoMapper, Spec::Example::ExampleGroup)
+end

data/lib/remarkable/mongo_mapper/base.rb

@@ -0,0 +1,223 @@
+module Remarkable
+  module MongoMapper
+    class Base < Remarkable::Base
+      I18N_COLLECTION = [ :attributes, :associations ]
+
+      # Provides a way to send options to all MongoMapper matchers.
+      #
+      #   validates_presence_of(:name).with_options(:allow_nil => false)
+      #
+      # Is equivalent to:
+      #
+      #   validates_presence_of(:name, :allow_nil => false)
+      #
+      def with_options(opts={})
+        @options.merge!(opts)
+        self
+      end
+
+      protected
+
+        # Checks for the given key in @options, if it exists and it's true,
+        # tests that the value is bad, otherwise tests that the value is good.
+        #
+        # It accepts the key to check for, the value that is used for testing
+        # and an @options key where the message to search for is.
+        #
+        def assert_bad_or_good_if_key(key, value, message_key=:message) #:nodoc:
+          return positive? unless @options.key?(key)
+
+          if @options[key]
+            return bad?(value, message_key), :not => not_word
+          else
+            return good?(value, message_key), :not => ''
+          end
+        end
+
+        # Checks for the given key in @options, if it exists and it's true,
+        # tests that the value is good, otherwise tests that the value is bad.
+        #
+        # It accepts the key to check for, the value that is used for testing
+        # and an @options key where the message to search for is.
+        #
+        def assert_good_or_bad_if_key(key, value, message_key=:message) #:nodoc:
+          return positive? unless @options.key?(key)
+
+          if @options[key]
+            return good?(value, message_key), :not => ''
+          else
+            return bad?(value, message_key), :not => not_word
+          end
+        end
+
+        # Default allow_nil? validation. It accepts the message_key which is
+        # the key which contain the message in @options.
+        #
+        # It also gets an allow_nil message on remarkable.mongo_mapper.allow_nil
+        # to be used as default.
+        #
+        def allow_nil?(message_key=:message) #:nodoc:
+          assert_good_or_bad_if_key(:allow_nil, nil, message_key)
+        end
+
+        # Default allow_blank? validation. It accepts the message_key which is
+        # the key which contain the message in @options.
+        #
+        # It also gets an allow_blank message on remarkable.mongo_mapper.allow_blank
+        # to be used as default.
+        #
+        def allow_blank?(message_key=:message) #:nodoc:
+          assert_good_or_bad_if_key(:allow_blank, '', message_key)
+        end
+
+        # Shortcut for assert_good_value.
+        #
+        def good?(value, message_sym=:message) #:nodoc:
+          assert_good_value(@subject, @attribute, value, @options[message_sym])
+        end
+
+        # Shortcut for assert_bad_value.
+        #
+        def bad?(value, message_sym=:message) #:nodoc:
+          assert_bad_value(@subject, @attribute, value, @options[message_sym])
+        end
+
+        # Asserts that an MongoMapper model validates with the passed
+        # <tt>value</tt> by making sure the <tt>error_message_to_avoid</tt> is not
+        # contained within the list of errors for that attribute.
+        #
+        #   assert_good_value(User.new, :email, "user@example.com")
+        #   assert_good_value(User.new, :ssn, "123456789", /length/)
+        #
+        # If a class is passed as the first argument, a new object will be
+        # instantiated before the assertion.  If an instance variable exists with
+        # the same name as the class (underscored), that object will be used
+        # instead.
+        #
+        #   assert_good_value(User, :email, "user@example.com")
+        #
+        #   @product = Product.new(:tangible => false)
+        #   assert_good_value(Product, :price, "0")
+        #
+        def assert_good_value(model, attribute, value, error_message_to_avoid=//) # :nodoc:
+          model.send("#{attribute}=", value)
+
+          return true if model.valid?
+          
+          error_message_to_avoid = error_message_from_model(model, attribute, error_message_to_avoid)
+          assert_does_not_contain(model.errors.on(attribute), error_message_to_avoid)
+        end
+
+        # Asserts that an MongoMapper model invalidates the passed
+        # <tt>value</tt> by making sure the <tt>error_message_to_expect</tt> is
+        # contained within the list of errors for that attribute.
+        #
+        #   assert_bad_value(User.new, :email, "invalid")
+        #   assert_bad_value(User.new, :ssn, "123", /length/)
+        #
+        # If a class is passed as the first argument, a new object will be
+        # instantiated before the assertion.  If an instance variable exists with
+        # the same name as the class (underscored), that object will be used
+        # instead.
+        #
+        #   assert_bad_value(User, :email, "invalid")
+        #
+        #   @product = Product.new(:tangible => true)
+        #   assert_bad_value(Product, :price, "0")
+        #
+        def assert_bad_value(model, attribute, value, error_message_to_expect=:invalid) #:nodoc:
+          model.send("#{attribute}=", value)
+
+          return false if model.valid? || model.errors.on(attribute).blank?
+          
+          error_message_to_expect = error_message_from_model(model, attribute, error_message_to_expect)
+          assert_contains(model.errors.on(attribute), error_message_to_expect)
+        end
+
+        # Return the error message to be checked. If the message is not a Symbol
+        # neither a Hash, it returns the own message.
+        #
+        # But the nice thing is that when the message is a Symbol we get the error
+        # messsage from within the model, using already existent structure inside
+        # MongoMapper.
+        #
+        # This allows a couple things from the user side:
+        #
+        #   1. Specify symbols in their tests:
+        #
+        #     should_allow_values_for(:shirt_size, 'S', 'M', 'L', :message => :inclusion)
+        #
+        #   As we know, allow_values_for searches for a :invalid message. So if we
+        #   were testing a validates_inclusion_of with allow_values_for, previously
+        #   we had to do something like this:
+        #
+        #     should_allow_values_for(:shirt_size, 'S', 'M', 'L', :message => 'not included in list')
+        #
+        #   Now everything gets resumed to a Symbol.
+        #
+        #   2. Do not worry with specs if their are using I18n API properly.
+        #
+        #   As we know, I18n API provides several interpolation options besides
+        #   fallback when creating error messages. If the user changed the message,
+        #   macros would start to pass when they shouldn't.
+        #
+        #   Using the underlying mechanism inside ActiveRecord makes us free from
+        #   all thos errors.
+        #
+        # We replace {{count}} interpolation for 12345 which later is replaced
+        # by a regexp which contains \d+.
+        #
+        def error_message_from_model(model, attribute, message) #:nodoc:
+          # FIXME
+          message
+        end
+
+        # Asserts that the given collection does not contain item x. If x is a
+        # regular expression, ensure that none of the elements from the collection
+        # match x.
+        #
+        def assert_does_not_contain(collection, x) #:nodoc:
+          !assert_contains(collection, x)
+        end
+
+        # Changes how collection are interpolated to provide localized names
+        # whenever is possible.
+        #
+        def collection_interpolation #:nodoc:
+          described_class = if @subject
+            subject_class
+          elsif @spec
+            @spec.send(:described_class)
+          end
+
+          if i18n_collection? && described_class.respond_to?(:human_attribute_name)
+            options = {}
+
+            collection_name = self.class.matcher_arguments[:collection].to_sym
+            if collection = instance_variable_get("@#{collection_name}")
+              collection = collection.map do |attr|
+                described_class.human_attribute_name(attr.to_s, :locale => Remarkable.locale).downcase
+              end
+              options[collection_name] = array_to_sentence(collection)
+            end
+
+            object_name = self.class.matcher_arguments[:as]
+            if object = instance_variable_get("@#{object_name}")
+              object = described_class.human_attribute_name(object.to_s, :locale => Remarkable.locale).downcase
+              options[object_name] = object
+            end
+
+            options
+          else
+            super
+          end
+        end
+
+        # Returns true if the given collection should be translated.
+        #
+        def i18n_collection? #:nodoc:
+          RAILS_I18N && I18N_COLLECTION.include?(self.class.matcher_arguments[:collection])
+        end
+    end
+  end
+end

data/lib/remarkable/mongo_mapper/describe.rb

@@ -0,0 +1,199 @@
+module Remarkable
+  module ActiveRecord
+
+    def self.after_include(target) #:nodoc:
+      target.class_inheritable_reader :describe_subject_attributes, :default_subject_attributes
+      target.send :include, Describe
+    end
+
+    # Overwrites describe to provide quick way to configure your subject:
+    #
+    #   describe Post
+    #     should_validate_presente_of :title
+    #
+    #     describe :published => true do
+    #       should_validate_presence_of :published_at
+    #     end
+    #   end
+    #
+    # This is the same as:
+    #
+    #   describe Post
+    #     should_validate_presente_of :title
+    #
+    #     describe "when published is true" do
+    #       subject { Post.new(:published => true) }
+    #       should_validate_presence_of :published_at
+    #     end
+    #   end
+    #
+    # The string can be localized using I18n. An example yml file is:
+    #
+    #   locale:
+    #     remarkable:
+    #       mongo_mapper:
+    #         describe:
+    #           each: "{{key}} is {{value}}"
+    #           prepend: "when "
+    #           connector: " and "
+    #
+    # You can also call subject attributes to set the default attributes for a
+    # subject. You can even mix with a fixture replacement tool:
+    #
+    #   describe Post
+    #     # Fixjour example
+    #     subject_attributes { valid_post_attributes }
+    #
+    #     describe :published => true do
+    #       should_validate_presence_of :published_at
+    #     end
+    #   end
+    #
+    # You can retrieve the merged result of all attributes given using the
+    # subject_attributes instance method:
+    #
+    #   describe Post
+    #     # Fixjour example
+    #     subject_attributes { valid_post_attributes }
+    #
+    #     describe :published => true do
+    #       it "should have default subject attributes" do
+    #         subject_attributes.should == { :title => 'My title', :published => true }
+    #       end
+    #     end
+    #   end
+    #
+    module Describe
+
+      def self.included(base) #:nodoc:
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        # Overwrites describe to provide quick way to configure your subject:
+        #
+        #   describe Post
+        #     should_validate_presente_of :title
+        #
+        #     describe :published => true do
+        #       should_validate_presence_of :published_at
+        #     end
+        #   end
+        #
+        # This is the same as:
+        #
+        #   describe Post
+        #     should_validate_presente_of :title
+        #
+        #     describe "when published is true" do
+        #       subject { Post.new(:published => true) }
+        #       should_validate_presence_of :published_at
+        #     end
+        #   end
+        #
+        # The string can be localized using I18n. An example yml file is:
+        #
+        #   locale:
+        #     remarkable:
+        #       mongo_mapper:
+        #         describe:
+        #           each: "{{key}} is {{value}}"
+        #           prepend: "when "
+        #           connector: " and "
+        #
+        # See also subject_attributes instance and class methods for more
+        # information.
+        #
+        def describe(*args, &block)
+          if described_class && args.first.is_a?(Hash)
+            attributes = args.shift
+
+            connector = Remarkable.t "remarkable.mongo_mapper.describe.connector", :default => " and "
+
+            description = if self.describe_subject_attributes.blank?
+              Remarkable.t("remarkable.mongo_mapper.describe.prepend", :default => "when ")
+            else
+              connector.lstrip
+            end
+
+            pieces = []
+            attributes.each do |key, value|
+              translated_key = if described_class.respond_to?(:human_attribute_name)
+                described_class.human_attribute_name(key.to_s, :locale => Remarkable.locale)
+              else
+                key.to_s.humanize
+              end
+
+              pieces << Remarkable.t("remarkable.mongo_mapper.describe.each",
+                                      :default => "{{key}} is {{value}}",
+                                      :key => translated_key.downcase, :value => value.inspect)
+            end
+
+            description << pieces.join(connector)
+            args.unshift(description)
+
+            # Creates an example group, set the subject and eval the given block.
+            #
+            example_group = super(*args) do
+              write_inheritable_hash(:describe_subject_attributes, attributes)
+              set_described_subject!
+              instance_eval(&block)
+            end
+          else
+            super(*args, &block)
+          end
+        end
+
+        # Sets default attributes for the subject. You can use this to set up
+        # your subject with valid attributes. You can even mix with a fixture
+        # replacement tool and still use quick subjects:
+        #
+        #   describe Post
+        #     # Fixjour example
+        #     subject_attributes { valid_post_attributes }
+        #
+        #     describe :published => true do
+        #       should_validate_presence_of :published_at
+        #     end
+        #   end
+        #
+        def subject_attributes(options=nil, &block)
+          write_inheritable_attribute(:default_subject_attributes, options || block)
+          set_described_subject!
+        end
+
+        def set_described_subject!
+          subject {
+            record = self.class.described_class.new
+            record.send(:attributes=, subject_attributes, false)
+            record
+          }
+        end
+      end
+
+      # Returns a hash with the subject attributes declared using the
+      # subject_attributes class method and the attributes given using the
+      # describe method.
+      #
+      #   describe Post
+      #     subject_attributes { valid_post_attributes }
+      #
+      #     describe :published => true do
+      #       it "should have default subject attributes" do
+      #         subject_attributes.should == { :title => 'My title', :published => true }
+      #       end
+      #     end
+      #   end
+      #
+      def subject_attributes
+        default = self.class.default_subject_attributes
+        default = self.instance_eval(&default) if default.is_a?(Proc)
+        default ||= {}
+
+        default.merge(self.class.describe_subject_attributes || {})
+      end
+
+    end
+  end
+end