carlosbrando-remarkable 0.0.99 → 2.2.1

data/lib/remarkable/controller/macros/route_matcher.rb

@@ -0,0 +1,75 @@
+module Remarkable # :nodoc:
+  module Controller # :nodoc:
+    module Matchers # :nodoc:
+      class Route < Remarkable::Matcher::Base
+        def initialize(method, path, options)
+          @method  = method
+          @path    = path
+          @options = options
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          initialize_with_spec!
+
+          unless @options[:controller]
+            @options[:controller] = @controller.class.name.gsub(/Controller$/, '').tableize
+          end
+          @options[:controller] = @options[:controller].to_s
+          @options[:action] = @options[:action].to_s
+
+          @populated_path = @path.dup
+          @options.each do |key, value|
+            @options[key] = value.to_param if value.respond_to?(:to_param)
+            @populated_path.gsub!(key.inspect, value.to_s)
+          end
+
+          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+          assert_matcher do
+            map_to_path? &&
+            generate_params?
+          end
+        end
+
+        def description
+          expectation
+        end
+
+        private
+
+        def initialize_with_spec!
+          # In Rspec 1.1.12 we can actually do:
+          #
+          #   @controller = @subject
+          #
+          @controller = @spec.instance_eval { controller }
+        end
+
+        def map_to_path?
+          route_for = ActionController::Routing::Routes.generate(@options) rescue nil
+          return true if route_for == @populated_path
+
+          @missing = "not map #{@options.inspect} to #{@path.inspect}"
+          return false
+        end
+
+        def generate_params?
+          params_from = ActionController::Routing::Routes.recognize_path(@populated_path, :method => @method.to_sym)
+          return true if params_from == @options
+
+          @missing = "not generate params #{@options.inspect} from #{@method.to_s.upcase} to #{@path.inspect}"
+          return false
+        end
+
+        def expectation
+          "route #{@method.to_s.upcase} #{@populated_path} to/from #{@options.inspect}"
+        end
+      end
+
+      def route(method, path, options)
+        Route.new(method, path, options)
+      end
+    end
+  end
+end

data/lib/remarkable/controller/macros/set_the_flash_to_matcher.rb

@@ -0,0 +1,60 @@
+module Remarkable # :nodoc:
+  module Controller # :nodoc:
+    module Matchers # :nodoc:
+      class SetTheFlashTo < Remarkable::Matcher::Base
+        include Remarkable::Controller::Helpers
+        
+        def initialize(val)
+          @val = val
+        end
+
+        def matches?(subject)
+          initialize_with_spec!
+
+          @subject = subject
+          assert_matcher do
+            flash_correct?
+          end
+        end
+
+        def description
+          expectation
+        end
+
+        private
+
+        def initialize_with_spec!
+          # In Rspec 1.1.12 we can actually do:
+          #
+          #   @flash = @subject.flash
+          #
+          @flash = @spec.instance_eval { flash }
+        end
+
+        def flash_correct?
+          if @val
+            return true if assert_contains(@flash.values, @val)
+            @missing = "not have #{@val} in the flash"
+          else
+            return true if @flash == {}
+            @missing = "flash is not empty"
+          end
+          return false
+        end
+        
+        def expectation
+          if @val
+            "have #{@val.inspect} in the flash"
+          else
+            "set the flash"
+          end
+        end
+      end
+
+      def set_the_flash_to(val = '')
+        SetTheFlashTo.new(val)
+      end
+      alias_method :set_the_flash, :set_the_flash_to
+    end
+  end
+end

data/lib/remarkable/controller/macros.rb

@@ -0,0 +1,78 @@
+module Remarkable # :nodoc:
+  module Controller # :nodoc:
+    module Macros # :nodoc:
+      include Matchers
+
+      def should_render_template(template)
+        it "should render template #{template.inspect}" do
+          response.should render_template(template.to_s)
+        end
+      end
+
+      def should_not_render_template(template)
+        it "should render template #{template.inspect}" do
+          response.should_not render_template(template.to_s)
+        end
+      end
+
+      def should_redirect_to(url)
+        it "should redirect to #{url.inspect}" do
+          redirect_url = self.instance_eval(url) rescue url
+          response.should redirect_to(redirect_url)
+        end
+      end
+
+      def should_not_redirect_to(url)
+        it "should not redirect to #{url.inspect}" do
+          redirect_url = self.instance_eval(url) rescue url
+          response.should_not redirect_to(redirect_url)
+        end
+      end
+
+      def should_not_set_the_flash
+        should_method_missing :set_the_flash_to, nil
+      end
+
+      def method_missing_with_remarkable(method_id, *args, &block)
+        if method_id.to_s =~ /^should_not_(.*)/
+          should_not_method_missing($1, *args)
+        elsif method_id.to_s =~ /^should_(.*)/
+          should_method_missing($1, *args)
+        elsif method_id.to_s =~ /^xshould_(not_)?(.*)/
+          pending_method_missing($2, $1, *args)
+        else
+          method_missing_without_remarkable(method_id, *args, &block)
+        end
+      end
+      alias_method_chain :method_missing, :remarkable
+
+      private
+
+      def should_method_missing(method, *args)
+        matcher = send(method, *args)
+        it "should #{matcher.description}" do
+          matcher.spec(self)
+          assert_accepts(matcher, subject_class)
+        end
+      end
+
+      def should_not_method_missing(method, *args)
+        matcher = send(method, *args)
+        it "should not #{matcher.description}" do
+          matcher.spec(self).negative
+          assert_rejects(matcher, subject_class)
+        end
+      end
+
+      def pending_method_missing(method, negative, *args)
+        matcher = send(method, *args)
+        matcher.negative if negative
+        description = matcher.description
+        xit "should #{'not ' if negative}#{description}"
+      rescue
+        xit "should #{'not ' if negative}#{method.to_s.gsub('_',' ')}"
+      end
+
+    end
+  end
+end

data/lib/remarkable/dsl.rb

@@ -0,0 +1,239 @@
+module Remarkable # :nodoc:
+  module Matcher # :nodoc:
+    module DSL
+
+      def self.included(base)
+        base.extend ClassMethods
+        base.class_eval do
+          class_inheritable_accessor :loop_argument, :instance_writer => false
+          class_inheritable_reader   :matcher_for_assertions, :matcher_assertions
+
+          # loop_argument is the value the we are going to loop with
+          # assert_matcher_for.
+          self.loop_argument = nil
+
+          # matcher_for_assertions contains the methods that should be called
+          # inside assert_matcher_for.
+          assertions()
+
+          # matcher_assertions contains the methods that should be called
+          # inside assert_matcher.
+          single_assertions()
+        end
+      end
+
+      module ClassMethods
+
+        protected
+
+          def assertions(*methods)
+            write_inheritable_array(:matcher_for_assertions, methods)
+          end
+
+          def single_assertions(*methods)
+            write_inheritable_array(:matcher_assertions, methods)
+          end
+
+          # Creates optional handlers for matchers dynamically. The following
+          # statement:
+          #
+          #   optional :range, :default => 0..10
+          #
+          # Will generate:
+          #
+          #   def range(value=0..10)
+          #     @options ||= {}
+          #     @options[:range] = value
+          #     self
+          #   end
+          #
+          # Options:
+          #
+          # * <tt>:default</tt> - The default value for this optional
+          # * <tt>:alias</tt>  - An alias for this optional
+          #
+          # Examples:
+          #
+          #   optional :name, :title
+          #   optional :range, :default => 0..10, :alias => :within
+          #
+          def optional(*names)
+            options = names.extract_options!
+            names.each do |name|
+              class_eval <<-END, __FILE__, __LINE__
+def #{name}(value#{ options[:default] ? "=#{options[:default].inspect}" : "" })
+  @options ||= {}
+  @options[:#{name}] = value
+  self
+end
+END
+            end
+            class_eval "alias_method(:#{options[:alias]}, :#{names.last})" if options[:alias]
+          end
+
+          # It sets the arguments your matcher receives on initialization. The
+          # last name given must be always plural and it will be the values
+          # that the matcher loops with. For example:
+          #
+          #   @product.shuold validate_presence_of(:title, :name)
+          #
+          # validate_presence_of is a matcher declared as:
+          #
+          #   class ValidatePresenceOfMatcher < Remarkable::Matcher::Base
+          #     arguments :attributes
+          #   end
+          #
+          # And this is the same as:
+          #
+          #   class ValidatePresenceOfMatcher < Remarkable::Matcher::Base
+          #     def initialize(*attributes)
+          #       load_options(attributes.extract_options!)
+          #       @attributes = attributes
+          #     end
+          #   end
+          #
+          # As you noticed, it will set instance variable with same name of the
+          # given values in <tt>arguments</tt>. Also, for each attribute given
+          # in @attributes the matcher will run all assertions declared with
+          # <tt>assertions</tt>.
+          #
+          # So validate_presence_of can be written as:
+          #
+          #   class ValidatePresenceOfMatcher < Remarkable::Matcher::Base
+          #     arguments  :attributes
+          #     assertions :check_nil
+          #
+          #     protected
+          #       def check_nil
+          #         @subject.send("#{@attribute}=", nil)
+          #         !@subject.save
+          #       end
+          #   end
+          #
+          # What it does is simple. For each attribute in @attributes, it will
+          # set the @attribute variable (in singular) and then call :check_nil.
+          #
+          # In check_nil, we can also see an instance_variable called @subject
+          # which is the object we called should on. Then we set the attribute
+          # given to nil and tries to save the object.
+          #
+          # If check nil returns true, that means the value does not accept nil
+          # and then it validate_presence_of is checked. If it return false for
+          # any given attribute, it will not pass.
+          #
+          # Let's see more examples:
+          #
+          #   should allow_values_for(:email, "jose@valim.com", "carlos@brando.com")
+          #
+          # Is declared as:
+          #
+          #   arguments :attribute, :good_values
+          #
+          # And this is the same as:
+          #
+          #   class AllowValuesForMatcher < Remarkable::Matcher::Base
+          #     def initialize(attribute, *good_values)
+          #       @attribute = attribute
+          #       load_options(good_values.extract_options!)
+          #       @good_values = good_values
+          #     end
+          #   end
+          #
+          # Now, the variable we will loop is @good_values. In each assertion
+          # method we will have a @good_value variable instantiated with the
+          # value to assert. The instance variable @attribute is also available
+          # and is always the same, since it's not the variable we are looping.
+          #
+          def arguments(*names)
+            self.loop_argument = names.pop.to_s
+            args               = (names + [ "*#{self.loop_argument}" ]).join(', ')
+
+            assignments = names.map do |name|
+              "@#{name} = #{name}"
+            end.join("\n")
+
+            # TODO:
+            #
+            # Do:
+            #
+            #   @options = default_options.merge(#{self.loop_argument}.extract_options!)
+            #
+            # Instead of:
+            #
+            #   load_options(#{self.loop_argument}.extract_options!)
+            #
+            # And deprecate load_options.
+            #
+            class_eval <<-END, __FILE__, __LINE__
+def initialize(#{args})
+  #{assignments}
+  load_options(#{self.loop_argument}.extract_options!)
+  @#{self.loop_argument} = #{self.loop_argument}
+  after_initialize!
+end
+END
+          end
+      end
+
+      def matches?(subject)
+        @subject = subject
+
+        # Execute before_assert! callback
+        before_assert!
+
+        # Gets the loop_argument and loops it setting the singular name of
+        # loop argument. For example, if loop_argument is :good_values, we
+        # will get @good_values and then set the instance variable @good_value.
+        #
+        # Then we go for each method declared in assertions and eval it.
+        # Later we do the same for each method declared in single_assertion.
+        #
+        assert_matcher_for(instance_variable_get("@#{loop_argument}")) do |value|
+          instance_variable_set("@#{loop_argument.singularize}", value)
+
+          matcher_for_assertions.inject(true) do |bool, method|
+            bool && send_assertion_method(method)
+          end
+        end &&
+        assert_matcher do
+          matcher_assertions.inject(true) do |bool, method|
+            bool && send_assertion_method(method)
+          end
+        end
+      end
+
+      protected
+
+        # Do not overwrite this method. It's going to be deprecated.
+        #
+        def load_options(options = {})
+          @options = default_options.merge(options)
+        end
+
+        # Overwrite to provide default options.
+        #
+        def default_options
+          {}
+        end
+
+        def send_assertion_method(method)
+          if method.is_a? Array
+            send(*method)
+          else
+            send(method)
+          end
+        end
+
+        # Callback called after initialization.
+        #
+        def after_initialize!
+        end
+
+        # Callback before begin assertions.
+        #
+        def before_assert!
+        end
+
+    end
+  end
+end

data/lib/remarkable/example/example_methods.rb

@@ -2,20 +2,26 @@ module Spec
   module Example
     module ExampleMethods
       def should(matcher)
-        case matcher.class.name
-        when "Spec::Rails::Matchers::RenderTemplate", "Spec::Rails::Matchers::RedirectTo"
+        if rspec_rails_controller_matcher?(matcher)
           remarkable_response.should matcher
+        elsif remarkable_matcher?(matcher)
+          remarkable_subject.should matcher.spec(self)
+        elsif exists_a_rspec_subject?
+          subject.should(matcher)
         else
-          remarkable_subject.should matcher
+          super
         end
       end
 
       def should_not(matcher)
-        case matcher.class.name
-        when "Spec::Rails::Matchers::RenderTemplate", "Spec::Rails::Matchers::RedirectTo"
+        if rspec_rails_controller_matcher?(matcher)
           remarkable_response.should_not matcher
+        elsif remarkable_matcher?(matcher)
+          remarkable_subject.should_not matcher.spec(self).negative
+        elsif exists_a_rspec_subject?
+          subject.should_not(matcher)
         else
-          remarkable_subject.should_not matcher
+          super
         end
       end
 
@@ -25,7 +31,21 @@ module Spec
       end
 
       def remarkable_response
-        @remarkable_response ||= self.response if self.respond_to?(:response)        
+        @remarkable_response ||= self.response if self.respond_to?(:response)
+      end
+
+      private
+
+      def rspec_rails_controller_matcher?(matcher)
+        %w( Spec::Rails::Matchers::RenderTemplate Spec::Rails::Matchers::RedirectTo ).include?(matcher.class.name)
+      end
+
+      def remarkable_matcher?(matcher)
+        matcher.class.name =~ /^Remarkable::\w+::Matchers::.+$/
+      end
+
+      def exists_a_rspec_subject?
+        !subject.nil?
       end
     end
   end

data/lib/remarkable/helpers.rb

@@ -0,0 +1,28 @@
+module Remarkable # :nodoc:
+  module Default # :nodoc:
+    module Helpers # :nodoc:
+      # Asserts that the given collection contains item x.  If x is a regular expression, ensure that
+      # at least one element from the collection matches x.  +extra_msg+ is appended to the error message if the assertion fails.
+      #
+      #   assert_contains(['a', '1'], /\d/) => passes
+      #   assert_contains(['a', '1'], 'a') => passes
+      #   assert_contains(['a', '1'], /not there/) => fails
+      def assert_contains(collection, x) # :nodoc:
+        collection = [collection] unless collection.is_a?(Array)
+
+        case x
+        when Regexp
+          collection.detect { |e| e =~ x }
+        else         
+          collection.include?(x)
+        end
+      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
+    end
+  end
+end

data/lib/remarkable/matcher_base.rb

@@ -0,0 +1,64 @@
+module Remarkable # :nodoc:
+  module Matcher # :nodoc:
+    class Base
+      include Remarkable::Matcher::DSL
+
+      def negative
+        @negative = true
+        self
+      end
+
+      def failure_message
+        "Expected #{expectation} (#{@missing})"
+      end
+
+      def negative_failure_message
+        "Did not expect #{expectation}"
+      end
+
+      def spec(spec)
+        @spec = spec
+        self
+      end
+
+      private
+
+      def subject_class
+        @subject.is_a?(Class) ? @subject : @subject.class
+      end
+
+      def subject_name
+        subject_class.name
+      end
+
+      def positive?
+        @negative ? false : true
+      end
+
+      def negative?
+        @negative ? true : false
+      end
+
+      def assert_matcher(&block)
+        if positive?
+          return false unless yield
+        else
+          return true if yield
+        end
+        positive?
+      end
+
+      def assert_matcher_for(collection, &block)
+        collection.each do |item|
+          if positive?
+            return false unless yield(item)
+          else
+            return true if yield(item)
+          end
+        end
+        positive?
+      end
+
+    end
+  end
+end