remarkable 3.1.8 → 3.1.9

data/lib/remarkable/macros.rb

@@ -1,58 +1,58 @@
 module Remarkable
   # This class is responsable for converting matchers to macros. You shouldn't
   # worry with what happens here, because it happens automatically.
-  #
-  module Macros
-
-    protected
-
-      def method_missing(method_id, *args, &block) #:nodoc:
-        if method_id.to_s =~ /^(should_not|should)_(.+)/
-          should_or_should_not_method_missing($1, $2, caller, *args, &block)
-        elsif method_id.to_s =~ /^x(should_not|should)_(.+)/
-          disabled_method_missing($1, $2, *args, &block)
-        else
-          super(method_id, *args, &block)
-        end
-      end
-
+  #
+  module Macros
+
+    protected
+
+      def method_missing(method_id, *args, &block) #:nodoc:
+        if method_id.to_s =~ /^(should_not|should)_(.+)/
+          should_or_should_not_method_missing($1, $2, caller, *args, &block)
+        elsif method_id.to_s =~ /^x(should_not|should)_(.+)/
+          disabled_method_missing($1, $2, *args, &block)
+        else
+          super(method_id, *args, &block)
+        end
+      end
+
       def should_or_should_not_method_missing(should_or_should_not, method, calltrace, *args, &block) #:nodoc:
         description = if @_pending_group
           get_description_from_matcher(should_or_should_not, method, *args, &block)
         else
           nil
         end
-
-        example(description){
-          begin
-            send(should_or_should_not, send(method, *args, &block))
+
+        example(description){
+          begin
+            send(should_or_should_not, send(method, *args, &block))
           rescue Exception => e
-            trace = e.backtrace.to_a + calltrace.to_a
-            e.set_backtrace(trace)
-            raise e
-          end
-        }
-      end
-
-      def disabled_method_missing(should_or_should_not, method, *args, &block) #:nodoc:
-        description = get_description_from_matcher(should_or_should_not, method, *args, &block)
-        xexample(description)
-      end
-
-      # Try to get the description from the matcher. If an error is raised, we
-      # deduct the description from the matcher name, but it will be shown in
-      # english.
-      #
-      def get_description_from_matcher(should_or_should_not, method, *args, &block) #:nodoc:
-        verb = should_or_should_not.to_s.gsub('_', ' ')
-
-        desc = Remarkable::Matchers.send(method, *args, &block).spec(self).description
-        verb = Remarkable.t("remarkable.core.#{should_or_should_not}", :default => verb)
-      rescue
-        desc = method.to_s.gsub('_', ' ')
-      ensure
-        verb << ' ' << desc
-      end
-
-  end
-end
+            trace = e.backtrace.to_a + calltrace.to_a
+            e.set_backtrace(trace)
+            raise e
+          end
+        }
+      end
+
+      def disabled_method_missing(should_or_should_not, method, *args, &block) #:nodoc:
+        description = get_description_from_matcher(should_or_should_not, method, *args, &block)
+        xexample(description)
+      end
+
+      # Try to get the description from the matcher. If an error is raised, we
+      # deduct the description from the matcher name, but it will be shown in
+      # english.
+      #
+      def get_description_from_matcher(should_or_should_not, method, *args, &block) #:nodoc:
+        verb = should_or_should_not.to_s.gsub('_', ' ')
+
+        desc = Remarkable::Matchers.send(method, *args, &block).spec(self).description
+        verb = Remarkable.t("remarkable.core.#{should_or_should_not}", :default => verb)
+      rescue
+        desc = method.to_s.gsub('_', ' ')
+      ensure
+        verb << ' ' << desc
+      end
+
+  end
+end

data/lib/remarkable/matchers.rb

@@ -1,14 +1,14 @@
-# Remarkable core module
-module Remarkable
-  # A module that keeps all matchers added. This is useful because it allows
-  # to include matchers in Test::Unit as well.
-  module Matchers; end
-
+# Remarkable core module
+module Remarkable
+  # A module that keeps all matchers added. This is useful because it allows
+  # to include matchers in Test::Unit as well.
+  module Matchers; end
+
   # Helper that includes required Remarkable modules into the given klass.
   #
   # If the module to be included responds to :after_include, it's called with the
   # target as argument.
-  #
+  #
   def self.include_matchers!(base, target=nil)
     if target.nil?
       if rspec_defined?
@@ -19,22 +19,22 @@ module Remarkable
     end
 
     metaclass = (class << target; self; end)
-    target.send :extend, Remarkable::Pending unless metaclass.ancestors.include?(Remarkable::Pending)
+    target.send :extend, Remarkable::Pending unless metaclass.ancestors.include?(Remarkable::Pending)
     target.send :extend, Remarkable::Macros  unless metaclass.ancestors.include?(Remarkable::Macros)
-
-    if defined?(base::Matchers)
-      target.send :include, base::Matchers
-
-      Remarkable::Matchers.send :extend, base::Matchers
-      Remarkable::Matchers.send :include, base::Matchers
+
+    if defined?(base::Matchers)
+      target.send :include, base::Matchers
+
+      Remarkable::Matchers.send :extend, base::Matchers
+      Remarkable::Matchers.send :include, base::Matchers
     end
 
     if base.respond_to?(:after_include)
       base.after_include(target)
-    end
+    end
   end
 
   def self.rspec_defined? #:nodoc:
     defined?(Spec)
-  end
-end
+  end
+end

data/lib/remarkable/messages.rb

@@ -1,103 +1,103 @@
-module Remarkable
-  # Holds the methods required by rspec for each matcher plus a collection of
-  # helpers to deal with I18n.
-  #
-  module Messages
-
-    # Provides a default description message. Overwrite it if needed.
-    # By default it uses default i18n options, but without the subjects, which
-    # usually are not available when description is called.
-    #
-    def description(options={})
-      options = default_i18n_options.merge(options)
-
-      # Remove subject keys
-      options.delete(:subject_name)
-      options.delete(:subject_inspect)
-
-      Remarkable.t 'description', options
-    end
-
-    # Provides a default failure message. Overwrite it if needed.
-    #
-    def failure_message_for_should
-      Remarkable.t 'remarkable.core.failure_message_for_should', :expectation => @expectation
-    end
-    alias :failure_message :failure_message_for_should
-
-    # Provides a default negative failure message. Overwrite it if needed.
-    #
-    def failure_message_for_should_not
-      Remarkable.t 'remarkable.core.failure_message_for_should_not', :expectation => @expectation
-    end
-    alias :negative_failure_message :failure_message_for_should_not
-
-    private
-
-      # Returns the matcher scope in I18n.
-      #
-      # If the matcher is Remarkable::ActiveRecord::Matchers::ValidatePresenceOfMatcher
-      # the default scope will be:
-      #
-      #   'remarkable.active_record.validate_presence_of'
-      #
-      def matcher_i18n_scope
-        @matcher_i18n_scope ||= self.class.name.to_s.
-                                gsub(/::Matchers::/, '::').
-                                gsub(/::/, '.').
-                                gsub(/Matcher$/, '').
-                                gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-                                gsub(/([a-z\d])([A-Z])/,'\1_\2').
-                                tr("-", "_").
-                                downcase
-      end
-
-      # Matcher i18n options used in description, failure_message and
-      # negative_failure_message. It provides by default the subject_name and
-      # the subject_inspect value. But when used with DSL, it provides a whole
-      # bunch of options (check dsl/matches.rb for more information).
-      #
-      def default_i18n_options
-        interpolation_options.update(
-          :scope => matcher_i18n_scope,
-          :subject_name => subject_name,
-          :subject_inspect => @subject.inspect
-        )
-      end
-
-      # Method to be overwritten if user wants to provide more interpolation
-      # options to I18n.
-      #
-      def interpolation_options
-        {}
-      end
-
-      # Returns the not word from I18n API.
-      #
-      def not_word
-        Remarkable.t('remarkable.core.not', :default => 'not') + " "
-      end
-
-      # Converts an array to a sentence
-      #
-      def array_to_sentence(array, inspect=false, empty_default='')
-        words_connector     = Remarkable.t 'remarkable.core.helpers.words_connector'
-        two_words_connector = Remarkable.t 'remarkable.core.helpers.two_words_connector'
-        last_word_connector = Remarkable.t 'remarkable.core.helpers.last_word_connector'
-
-        array = array.map { |i| i.inspect } if inspect
-
-        case array.length
-          when 0
-            empty_default
-          when 1
-            array[0].to_s
-          when 2
-            "#{array[0]}#{two_words_connector}#{array[1]}"
-          else
-            "#{array[0...-1].join(words_connector)}#{last_word_connector}#{array[-1]}"
-        end
-      end
-
-  end
-end
+module Remarkable
+  # Holds the methods required by rspec for each matcher plus a collection of
+  # helpers to deal with I18n.
+  #
+  module Messages
+
+    # Provides a default description message. Overwrite it if needed.
+    # By default it uses default i18n options, but without the subjects, which
+    # usually are not available when description is called.
+    #
+    def description(options={})
+      options = default_i18n_options.merge(options)
+
+      # Remove subject keys
+      options.delete(:subject_name)
+      options.delete(:subject_inspect)
+
+      Remarkable.t 'description', options
+    end
+
+    # Provides a default failure message. Overwrite it if needed.
+    #
+    def failure_message_for_should
+      Remarkable.t 'remarkable.core.failure_message_for_should', :expectation => @expectation
+    end
+    alias :failure_message :failure_message_for_should
+
+    # Provides a default negative failure message. Overwrite it if needed.
+    #
+    def failure_message_for_should_not
+      Remarkable.t 'remarkable.core.failure_message_for_should_not', :expectation => @expectation
+    end
+    alias :negative_failure_message :failure_message_for_should_not
+
+    private
+
+      # Returns the matcher scope in I18n.
+      #
+      # If the matcher is Remarkable::ActiveRecord::Matchers::ValidatePresenceOfMatcher
+      # the default scope will be:
+      #
+      #   'remarkable.active_record.validate_presence_of'
+      #
+      def matcher_i18n_scope
+        @matcher_i18n_scope ||= self.class.name.to_s.
+                                gsub(/::Matchers::/, '::').
+                                gsub(/::/, '.').
+                                gsub(/Matcher$/, '').
+                                gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+                                gsub(/([a-z\d])([A-Z])/,'\1_\2').
+                                tr("-", "_").
+                                downcase
+      end
+
+      # Matcher i18n options used in description, failure_message and
+      # negative_failure_message. It provides by default the subject_name and
+      # the subject_inspect value. But when used with DSL, it provides a whole
+      # bunch of options (check dsl/matches.rb for more information).
+      #
+      def default_i18n_options
+        interpolation_options.update(
+          :scope => matcher_i18n_scope,
+          :subject_name => subject_name,
+          :subject_inspect => @subject.inspect
+        )
+      end
+
+      # Method to be overwritten if user wants to provide more interpolation
+      # options to I18n.
+      #
+      def interpolation_options
+        {}
+      end
+
+      # Returns the not word from I18n API.
+      #
+      def not_word
+        Remarkable.t('remarkable.core.not', :default => 'not') + " "
+      end
+
+      # Converts an array to a sentence
+      #
+      def array_to_sentence(array, inspect=false, empty_default='')
+        words_connector     = Remarkable.t 'remarkable.core.helpers.words_connector'
+        two_words_connector = Remarkable.t 'remarkable.core.helpers.two_words_connector'
+        last_word_connector = Remarkable.t 'remarkable.core.helpers.last_word_connector'
+
+        array = array.map { |i| i.inspect } if inspect
+
+        case array.length
+          when 0
+            empty_default
+          when 1
+            array[0].to_s
+          when 2
+            "#{array[0]}#{two_words_connector}#{array[1]}"
+          else
+            "#{array[0...-1].join(words_connector)}#{last_word_connector}#{array[-1]}"
+        end
+      end
+
+  end
+end

data/lib/remarkable/pending.rb

@@ -1,68 +1,68 @@
-module Remarkable
-
-  module Pending
-
-    # We cannot put the alias method in the module because it's a Ruby 1.8 bug
-    # http://coderrr.wordpress.com/2008/03/28/alias_methodmodule-bug-in-ruby-18/
-    #
+module Remarkable
+
+  module Pending
+
+    # We cannot put the alias method in the module because it's a Ruby 1.8 bug
+    # http://coderrr.wordpress.com/2008/03/28/alias_methodmodule-bug-in-ruby-18/
+    #
     def self.extended(base) #:nodoc:
-      if base.respond_to?(:example)
-        class << base
-          alias_method :example_without_pending, :example
-          alias_method :example, :example_with_pending
-          alias :it :example
-          alias :specify :example
+      if base.respond_to?(:example)
+        class << base
+          alias_method :example_without_pending, :example
+          alias_method :example, :example_with_pending
+          alias :it :example
+          alias :specify :example
         end
-      end
-    end
-
-    # Adds a pending block to your specs.
-    #
-    # == Examples
-    #
-    #   pending 'create manager resource' do
-    #     should_have_one :manager
-    #     should_validate_associated :manager
-    #   end
-    #
-    # By default, it executes the examples inside the pending block. So as soon
-    # as you add the has_one :manager relationship to your model, your specs
-    # will say that this was already fixed and there is no need to be treated
-    # as pending. To disable this behavior, you can give :execute => false:
-    #
-    #   pending 'create manager resource', :execute => false
-    #
-    def pending(*args, &block)
-      options = { :execute => true }.merge(args.extract_options!)
-
-      @_pending_group = true
-      @_pending_group_description = args.first || "TODO"
-      @_pending_group_execute = options.delete(:execute)
-
-      self.instance_eval(&block)
-
-      @_pending_group = false
-      @_pending_group_description = nil
-      @_pending_group_execute = nil
-    end
-
-    def example_with_pending(description=nil, options={}, backtrace=nil, &implementation) #:nodoc:
-      if block_given? && @_pending_group
-        pending_caller      = caller.detect{ |c| c !~ /method_missing'/ }
-        pending_description = @_pending_group_description
-
-        pending_block = if @_pending_group_execute
-          proc{ pending(pending_description){ self.instance_eval(&implementation) } }
-        else
-          proc{ pending(pending_description) }
-        end
-
-        example_without_pending(description, options, backtrace || pending_caller, &pending_block)
-      else
-        example_without_pending(description, options, backtrace || caller(0)[1], &implementation)
-      end
-    end
-
-  end
-
-end
+      end
+    end
+
+    # Adds a pending block to your specs.
+    #
+    # == Examples
+    #
+    #   pending 'create manager resource' do
+    #     should_have_one :manager
+    #     should_validate_associated :manager
+    #   end
+    #
+    # By default, it executes the examples inside the pending block. So as soon
+    # as you add the has_one :manager relationship to your model, your specs
+    # will say that this was already fixed and there is no need to be treated
+    # as pending. To disable this behavior, you can give :execute => false:
+    #
+    #   pending 'create manager resource', :execute => false
+    #
+    def pending(*args, &block)
+      options = { :execute => true }.merge(args.extract_options!)
+
+      @_pending_group = true
+      @_pending_group_description = args.first || "TODO"
+      @_pending_group_execute = options.delete(:execute)
+
+      self.instance_eval(&block)
+
+      @_pending_group = false
+      @_pending_group_description = nil
+      @_pending_group_execute = nil
+    end
+
+    def example_with_pending(description=nil, options={}, backtrace=nil, &implementation) #:nodoc:
+      if block_given? && @_pending_group
+        pending_caller      = caller.detect{ |c| c !~ /method_missing'/ }
+        pending_description = @_pending_group_description
+
+        pending_block = if @_pending_group_execute
+          proc{ pending(pending_description){ self.instance_eval(&implementation) } }
+        else
+          proc{ pending(pending_description) }
+        end
+
+        example_without_pending(description, options, backtrace || pending_caller, &pending_block)
+      else
+        example_without_pending(description, options, backtrace || caller(0)[1], &implementation)
+      end
+    end
+
+  end
+
+end