remarkable 3.0.1 → 3.0.2

data/lib/remarkable/dsl.rb

@@ -5,18 +5,18 @@ require File.join(dir, 'dsl', 'matches')
 require File.join(dir, 'dsl', 'callbacks')
 
 module Remarkable
-  module DSL
-    ATTR_READERS = [ :matcher_arguments, :matcher_optionals, :matcher_single_assertions,
-      :matcher_collection_assertions, :before_assert_callbacks, :after_initialize_callbacks
-    ] unless self.const_defined?(:ATTR_READERS)
+  module DSL
+    ATTR_READERS = [ :matcher_arguments, :matcher_optionals, :matcher_single_assertions,
+      :matcher_collection_assertions, :before_assert_callbacks, :after_initialize_callbacks
+    ] unless self.const_defined?(:ATTR_READERS)
 
-    def self.extended(base) #:nodoc:
-      base.extend Assertions
-      base.send :include, Callbacks
+    def self.extended(base) #:nodoc:
+      base.extend Assertions
+      base.send :include, Callbacks
       base.send :include, Matches
-      base.send :include, Optionals
-
-      # Initialize matcher_arguments hash with names as an empty array
+      base.send :include, Optionals
+
+      # Initialize matcher_arguments hash with names as an empty array
       base.instance_variable_set('@matcher_arguments', { :names => [] })
     end
 
@@ -28,11 +28,11 @@ module Remarkable
           attr_reader *ATTR_READERS
         end
       end
-
-      ATTR_READERS.each do |attr|
-        current_value = self.instance_variable_get("@#{attr}")
-        base.instance_variable_set("@#{attr}", current_value ? current_value.dup : [])
-      end
+
+      ATTR_READERS.each do |attr|
+        current_value = self.instance_variable_get("@#{attr}")
+        base.instance_variable_set("@#{attr}", current_value ? current_value.dup : [])
+      end
     end
   end
 end

data/lib/remarkable/dsl/assertions.rb

@@ -64,12 +64,12 @@ module Remarkable
           @matcher_arguments[:names] = names
 
           if collection = options.delete(:collection)
-            @matcher_arguments[:collection] = collection
-
+            @matcher_arguments[:collection] = collection
+
             if options[:as]
-              @matcher_arguments[:as] = options.delete(:as)
-            else
-              raise ArgumentError, 'You gave me :collection as option but have not give me :as as well'
+              @matcher_arguments[:as] = options.delete(:as)
+            else
+              raise ArgumentError, 'You gave me :collection as option but have not give me :as as well'
             end
 
             args          << "*#{collection}"
@@ -147,7 +147,7 @@ END
         # Or you can set the message in the instance variable @expectation in the
         # assertion method if you don't want to rely on I18n API.
         #
-        # As you might have noticed from the examples above, this method is also
+        # As you might have noticed from the examples above, this method is also
         # aliased as <tt>collection_assertion</tt>.
         #
         def collection_assertions(*methods, &block)
@@ -156,8 +156,8 @@ END
         end
         alias :collection_assertion :collection_assertions
 
-        # In contrast to <tt>collection_assertions</tt>, the methods given here
-        # are called just once. In other words, it does not iterate through the
+        # In contrast to <tt>collection_assertions</tt>, the methods given here
+        # are called just once. In other words, it does not iterate through the
         # collection given in arguments.
         #
         # It also accepts blocks and is aliased as assertion.

data/lib/remarkable/dsl/callbacks.rb

@@ -1,52 +1,52 @@
 module Remarkable
   module DSL
     module Callbacks
-
-      def self.included(base) #:nodoc:
-        base.extend ClassMethods
-      end
-
-      module ClassMethods
+
+      def self.included(base) #:nodoc:
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
         protected
           # Class method that accepts a block or a symbol which is called after initialization.
           #
-          def after_initialize(symbol=nil, &block)
-            if block_given?
-              @after_initialize_callbacks << block
-            elsif symbol
-              @after_initialize_callbacks << symbol
-            end
+          def after_initialize(symbol=nil, &block)
+            if block_given?
+              @after_initialize_callbacks << block
+            elsif symbol
+              @after_initialize_callbacks << symbol
+            end
           end
 
           # Class method that accepts a block or a symbol which is called before assertion.
           #
-          def before_assert(symbol=nil, &block)
-            if block_given?
-              @before_assert_callbacks << block
-            elsif symbol
-              @before_assert_callbacks << symbol
-            end
-          end
-      end
-
-      def run_after_initialize_callbacks #:nodoc:
-        self.class.after_initialize_callbacks.each do |method|
-          if method.is_a?(Proc)
-            instance_eval &method
-          elsif method.is_a?(Symbol)
-            send(method)
-          end
-        end
-      end
-
-      def run_before_assert_callbacks #:nodoc:
-        self.class.before_assert_callbacks.each do |method|
-          if method.is_a?(Proc)
-            instance_eval &method
-          elsif method.is_a?(Symbol)
-            send(method)
-          end
-        end
+          def before_assert(symbol=nil, &block)
+            if block_given?
+              @before_assert_callbacks << block
+            elsif symbol
+              @before_assert_callbacks << symbol
+            end
+          end
+      end
+
+      def run_after_initialize_callbacks #:nodoc:
+        self.class.after_initialize_callbacks.each do |method|
+          if method.is_a?(Proc)
+            instance_eval &method
+          elsif method.is_a?(Symbol)
+            send(method)
+          end
+        end
+      end
+
+      def run_before_assert_callbacks #:nodoc:
+        self.class.before_assert_callbacks.each do |method|
+          if method.is_a?(Proc)
+            instance_eval &method
+          elsif method.is_a?(Symbol)
+            send(method)
+          end
+        end
       end
 
     end

data/lib/remarkable/dsl/matches.rb

@@ -49,51 +49,51 @@ module Remarkable
           {}
         end
 
-        # Overwrites default_i18n_options to provide arguments and optionals
-        # to interpolation options.
-        #
-        # If you still need to provide more other interpolation options, you can
-        # do that in two ways:
-        #
-        # 1. Overwrite interpolation_options:
-        #
-        #   def interpolation_options
-        #     { :real_value => real_value }
-        #   end
-        #
-        # 2. Return a hash from your assertion method:
-        #
-        #   def my_assertion
-        #     return true if real_value == expected_value
-        #     return false, :real_value => real_value
-        #   end
-        #
+        # Overwrites default_i18n_options to provide arguments and optionals
+        # to interpolation options.
+        #
+        # If you still need to provide more other interpolation options, you can
+        # do that in two ways:
+        #
+        # 1. Overwrite interpolation_options:
+        #
+        #   def interpolation_options
+        #     { :real_value => real_value }
+        #   end
+        #
+        # 2. Return a hash from your assertion method:
+        #
+        #   def my_assertion
+        #     return true if real_value == expected_value
+        #     return false, :real_value => real_value
+        #   end
+        #
         # In both cases, :real_value will be available as interpolation option.
         #
         def default_i18n_options #:nodoc:
-          i18n_options = {}
-
-          @options.each do |key, value|
-            i18n_options[key] = value.inspect
-          end if @options
-
+          i18n_options = {}
+
+          @options.each do |key, value|
+            i18n_options[key] = value.inspect
+          end if @options
+
           # Also add arguments as interpolation options.
           self.class.matcher_arguments[:names].each do |name|
             i18n_options[name] = instance_variable_get("@#{name}").inspect
-          end
-
-          # Add collection interpolation options.
-          i18n_options.update(collection_interpolation)
-
-          # Add default options (highest priority). They should not be overwritten.
+          end
+
+          # Add collection interpolation options.
+          i18n_options.update(collection_interpolation)
+
+          # Add default options (highest priority). They should not be overwritten.
           i18n_options.update(super)
-        end
-
-        # Method responsible to add collection as interpolation.
-        #
-        def collection_interpolation #:nodoc:
-          options = {}
-
+        end
+
+        # Method responsible to add collection as interpolation.
+        #
+        def collection_interpolation #:nodoc:
+          options = {}
+
           if collection_name = self.class.matcher_arguments[:collection]
             collection_name = collection_name.to_sym
             collection = instance_variable_get("@#{collection_name}")
@@ -102,26 +102,26 @@ module Remarkable
             object_name = self.class.matcher_arguments[:as].to_sym
             object = instance_variable_get("@#{object_name}")
             options[object_name] = object if object
-          end
-
-          options
+          end
+
+          options
         end
 
-        # Send the assertion methods given and create a expectation message
-        # if any of those methods returns false.
-        #
-        # Since most assertion methods ends with an question mark and it's not
-        # readable in yml files, we remove question and exclation marks at the
-        # end of the method name before translating it. So if you have a method
-        # called is_valid? on I18n yml file we will check for a key :is_valid.
+        # Send the assertion methods given and create a expectation message
+        # if any of those methods returns false.
+        #
+        # Since most assertion methods ends with an question mark and it's not
+        # readable in yml files, we remove question and exclation marks at the
+        # end of the method name before translating it. So if you have a method
+        # called is_valid? on I18n yml file we will check for a key :is_valid.
         #
         def send_methods_and_generate_message(methods) #:nodoc:
           methods.each do |method|
-            bool, hash = send(method)
+            bool, hash = send(method)
 
-            unless bool
-              @expectation ||= Remarkable.t "expectations.#{method.to_s.gsub(/(\?|\!)$/, '')}",
-                                            default_i18n_options.merge(hash || {})
+            unless bool
+              @expectation ||= Remarkable.t "expectations.#{method.to_s.gsub(/(\?|\!)$/, '')}",
+                                            default_i18n_options.merge(hash || {})
               return false
             end
           end

data/lib/remarkable/dsl/optionals.rb

@@ -1,15 +1,15 @@
 module Remarkable
   module DSL
-    module Optionals
-
-      OPTIONAL_KEYS = [ :positive, :negative, :not_given ]
-
-      def self.included(base) #:nodoc:
-        base.extend ClassMethods
+    module Optionals
+
+      OPTIONAL_KEYS = [ :positive, :negative, :not_given ]
+
+      def self.included(base) #:nodoc:
+        base.extend ClassMethods
       end
-
-      module ClassMethods
-
+
+      module ClassMethods
+
         protected
 
           # Creates optional handlers for matchers dynamically. The following
@@ -28,7 +28,7 @@ module Remarkable
           # Options:
           #
           # * <tt>:default</tt> - The default value for this optional
-          # * <tt>:alias</tt>  - An alias for this optional
+          # * <tt>:alias</tt>  - An alias for this optional
           # * <tt>:splat</tt>  - Should be true if you expects multiple arguments
           #
           # Examples:
@@ -59,11 +59,11 @@ module Remarkable
           #   validate_uniqueness_of :project_id, :scope => :company_id, :case_sensitive => false
           #   #=> "validate uniqueness of project_id scoped to company_id and case insensitive"
           #
-          # The interpolation options available are "value" and "inspect". Where
-          # the first is the optional value transformed into a string and the
-          # second is the inspected value.
-          #
-          # Three keys are available to be used in I18n files and control how
+          # The interpolation options available are "value" and "inspect". Where
+          # the first is the optional value transformed into a string and the
+          # second is the inspected value.
+          #
+          # Three keys are available to be used in I18n files and control how
           # optionals are appended to your description:
           #
           #   * <tt>positive</tt> - When the optional is given and it evaluates to true (everything but false and nil).
@@ -72,9 +72,9 @@ module Remarkable
           #
           def optionals(*names)
             options = names.extract_options!
-            @matcher_optionals += names
-
-            splat   = options[:splat]   ? '*' : ''
+            @matcher_optionals += names
+
+            splat   = options[:splat]   ? '*' : ''
             default = options[:default] ? "=#{options[:default].inspect}" : ""
 
             names.each do |name|
@@ -90,50 +90,50 @@ module Remarkable
 
             # Call unique to avoid duplicate optionals.
             @matcher_optionals.uniq!
-          end
-          alias :optional :optionals
-
-          # Instead of appending, prepend optionals to the beginning of optionals
-          # array. This is important because this decide how the description
-          # message is generated.
-          #
-          def prepend_optionals(*names)
-            current_optionals  = @matcher_optionals.dup
-            @matcher_optionals = []
-            optional(*names)
-            @matcher_optionals += current_optionals
-            @matcher_optionals.uniq!
-          end
-          alias :prepend_optional :prepend_optionals
-
-      end
-
+          end
+          alias :optional :optionals
+
+          # Instead of appending, prepend optionals to the beginning of optionals
+          # array. This is important because this decide how the description
+          # message is generated.
+          #
+          def prepend_optionals(*names)
+            current_optionals  = @matcher_optionals.dup
+            @matcher_optionals = []
+            optional(*names)
+            @matcher_optionals += current_optionals
+            @matcher_optionals.uniq!
+          end
+          alias :prepend_optional :prepend_optionals
+
+      end
+
       # Overwrites description to support optionals. Check <tt>optional</tt> for
       # more information.
       #
       def description(options={}) #:nodoc:
-        message = super(options)
+        message = super(options)
         message.strip!
 
         optionals = self.class.matcher_optionals.map do |optional|
           scope = matcher_i18n_scope + ".optionals.#{optional}"
 
-          if @options.key?(optional)
+          if @options.key?(optional)
             value = @options[optional]
-            defaults = [ (value ? :positive : :negative) ]
-
-            # If optional is a symbol and it's not any to any of the reserved symbols, search for it also
-            defaults.unshift(value) if value.is_a?(Symbol) && !OPTIONAL_KEYS.include?(value)
+            defaults = [ (value ? :positive : :negative) ]
+
+            # If optional is a symbol and it's not any to any of the reserved symbols, search for it also
+            defaults.unshift(value) if value.is_a?(Symbol) && !OPTIONAL_KEYS.include?(value)
 
-            Remarkable.t defaults.shift, :default => defaults, :raise => true, :scope => scope,
-                                         :inspect => value.inspect, :value => value.to_s
+            Remarkable.t defaults.shift, :default => defaults, :raise => true, :scope => scope,
+                                         :inspect => value.inspect, :value => value.to_s
           else
             Remarkable.t :not_given, :raise => true, :scope => scope
           end rescue nil
         end.compact
 
-        message << ' ' << array_to_sentence(optionals)
-        message.strip!
+        message << ' ' << array_to_sentence(optionals)
+        message.strip!
         message
       end
 

data/lib/remarkable/macros.rb

@@ -1,48 +1,48 @@
 module Remarkable
-  module Macros
+  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)
+        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
+        else
           super(method_id, *args, &block)
         end
-      end
-
+      end
+
       def should_or_should_not_method_missing(should_or_should_not, method, calltrace, *args, &block) #:nodoc:
-        it {
-          begin
-            send(should_or_should_not, send(method, *args, &block))
-          rescue Exception => e
-            e.set_backtrace(calltrace.to_a)
-            raise e
-          end
+        it {
+          begin
+            send(should_or_should_not, send(method, *args, &block))
+          rescue Exception => e
+            e.set_backtrace(calltrace.to_a)
+            raise e
+          end
         }
-      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)
+      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
+
+      # 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