carlosbrando-remarkable 0.0.99 → 2.2.1

data/lib/remarkable/active_record/macros/validations/require_unique_attributes.rb

@@ -1,146 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class RequireUniqueAttributes
-        include Remarkable::Private
-        
-        def initialize(*attributes)
-          @message, scope = get_options!(attributes, :message, :scoped_to)
-          @scope = [*scope].compact
-          @message ||= default_error_message(:taken)
-
-          @attributes = attributes
-        end
-
-        def matches?(klass)
-          @klass = klass
-
-          begin
-            @attributes.each do |attribute|
-              attribute = attribute.to_sym
-
-              existing = klass.find(:first)
-              fail("Can't find first #{klass}") unless existing
-
-              object = klass.new
-              existing_value = existing.send(attribute)
-
-              if !@scope.blank?
-                @scope.each do |s|
-                  fail("#{klass.name} doesn't seem to have a #{s} attribute.") unless object.respond_to?(:"#{s}=")
-                  object.send("#{s}=", existing.send(s))
-                end
-              end
-              return false unless assert_bad_value(object, attribute, existing_value, @message)
-
-              # Now test that the object is valid when changing the scoped attribute
-              # TODO:  There is a chance that we could change the scoped field
-              # to a value that's already taken.  An alternative implementation
-              # could actually find all values for scope and create a unique
-              # one.
-              if !@scope.blank?
-                @scope.each do |s|
-                  # Assume the scope is a foreign key if the field is nil
-                  object.send("#{s}=", existing.send(s).nil? ? 1 : existing.send(s).next)
-                  return false unless assert_good_value(object, attribute, existing_value, @message)
-                end
-              end
-            end
-
-            true
-          rescue Exception => e
-            false
-          end
-        end
-
-        def description
-          "require unique value for #{@attributes.to_sentence}#{" scoped to #{@scope.to_sentence}" unless @scope.blank?}"
-        end
-
-        def failure_message
-          @failure_message || "expected that the #{@klass.name} cannot be saved if #{@attributes.to_sentence}#{" scoped to #{@scope.to_sentence}" unless @scope.blank?} is not unique, but it did"
-        end
-
-        def negative_failure_message
-          "expected that the #{@klass.name} can be saved if #{@attributes.to_sentence}#{" scoped to #{@scope.to_sentence}" unless @scope.blank?} is not unique, but it didn't"
-        end
-      end
-
-      # Ensures that the model cannot be saved if one of the attributes listed is not unique.
-      # Requires an existing record
-      #
-      # Options:
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.taken')</tt>
-      # * <tt>:scoped_to</tt> - field(s) to scope the uniqueness to.
-      #
-      # Examples:
-      #   should_require_unique_attributes :keyword, :username
-      #   should_require_unique_attributes :name, :message => "O NOES! SOMEONE STOELED YER NAME!"
-      #   should_require_unique_attributes :email, :scoped_to => :name
-      #   should_require_unique_attributes :address, :scoped_to => [:first_name, :last_name]
-      #
-      def require_unique_attributes(*attributes)
-        Remarkable::Syntax::RSpec::RequireUniqueAttributes.new(*attributes)
-      end
-    end
-
-    module Shoulda
-      # Ensures that the model cannot be saved if one of the attributes listed is not unique.
-      # Requires an existing record
-      #
-      # Options:
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.taken')</tt>
-      # * <tt>:scoped_to</tt> - field(s) to scope the uniqueness to.
-      #
-      # Examples:
-      #   should_require_unique_attributes :keyword, :username
-      #   should_require_unique_attributes :name, :message => "O NOES! SOMEONE STOELED YER NAME!"
-      #   should_require_unique_attributes :email, :scoped_to => :name
-      #   should_require_unique_attributes :address, :scoped_to => [:first_name, :last_name]
-      #
-      def should_require_unique_attributes(*attributes)
-        message, scope = get_options!(attributes, :message, :scoped_to)
-        scope = [*scope].compact
-        message ||= default_error_message(:taken)
-
-        klass = model_class
-        attributes.each do |attribute|
-          attribute = attribute.to_sym
-          it "should require unique value for #{attribute}#{" scoped to #{scope.join(', ')}" unless scope.blank?}" do
-            existing = klass.find(:first)
-            fail_with("Can't find first #{klass}") unless existing
-            object = klass.new
-            existing_value = existing.send(attribute)
-
-            if !scope.blank?
-              scope.each do |s|
-                unless object.respond_to?(:"#{s}=")
-                  fail_with "#{klass.name} doesn't seem to have a #{s} attribute."
-                end
-                object.send("#{s}=", existing.send(s))
-              end
-            end
-            assert_bad_value(object, attribute, existing_value, message).should be_true
-            
-            # Now test that the object is valid when changing the scoped attribute
-            # TODO:  There is a chance that we could change the scoped field
-            # to a value that's already taken.  An alternative implementation
-            # could actually find all values for scope and create a unique
-            # one.
-            if !scope.blank?
-              scope.each do |s|
-                # Assume the scope is a foreign key if the field is nil
-                object.send("#{s}=", existing.send(s).nil? ? 1 : existing.send(s).next)
-                assert_good_value(object, attribute, existing_value, message).should be_true
-              end
-            end
-          end
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,110 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      # Macro that creates a test asserting that the controller assigned to
-      # each of the named instance variable(s).
-      #
-      # Options:
-      # * <tt>:class</tt> - The expected class of the instance variable being checked.
-      # * <tt>:equals</tt> - A string which is evaluated and compared for equality with
-      # the instance variable being checked.
-      #
-      # Example:
-      #
-      #   it { should assign_to(:user, :posts) }
-      #   it { should assign_to(:user, :class => User) }
-      #   it { should assign_to(:user, :equals => '@user') }
-      # 
-      def assign_to(*names)
-        opts = names.extract_options!
-        test_name = "assign @#{names.to_sentence}"
-        test_name << " as class #{opts[:class]}" if opts[:class]
-        test_name << " which is equal to #{opts[:equals]}" if opts[:equals]
-
-        simple_matcher test_name do |controller, matcher|
-          ret = true
-          names.each do |name|
-            assigned_value = assigns(name.to_sym)
-
-            unless assigned_value
-              ret = false
-              break
-            end
-
-            if opts[:class]
-              unless assigned_value.kind_of?(opts[:class])
-                ret = false
-                break
-              end
-            end
-
-            if opts[:equals]
-              instantiate_variables_from_assigns do
-                expected_value = eval(opts[:equals], self.send(:binding), __FILE__, __LINE__)
-                unless assigned_value == expected_value
-                  ret = false
-                  break
-                end
-              end
-            end
-          end
-
-          ret
-        end
-      end
-    end
-
-    module Shoulda
-      # Macro that creates a test asserting that the controller assigned to
-      # each of the named instance variable(s).
-      #
-      # Options:
-      # * <tt>:class</tt> - The expected class of the instance variable being checked.
-      # * <tt>:equals</tt> - A string which is evaluated and compared for equality with
-      # the instance variable being checked.
-      #
-      # Example:
-      #
-      #   should_assign_to :user, :posts
-      #   should_assign_to :user, :class => User
-      #   should_assign_to :user, :equals => '@user'
-      # 
-      def should_assign_to(*names)
-        opts = names.extract_options!
-        names.each do |name|
-          test_name = "should assign @#{name}"
-          test_name << " as class #{opts[:class]}" if opts[:class]
-          test_name << " which is equal to #{opts[:equals]}" if opts[:equals]
-          it test_name do
-            assigned_value = assigns(name.to_sym)
-            assigned_value.should_not be_nil
-            assigned_value.should be_a_kind_of(opts[:class]) if opts[:class]
-            if opts[:equals]
-              instantiate_variables_from_assigns do
-                expected_value = eval(opts[:equals], self.send(:binding), __FILE__, __LINE__)
-                assigned_value.should == expected_value
-              end
-            end
-          end
-        end
-      end
-
-      # Macro that creates a test asserting that the controller did not assign to
-      # any of the named instance variable(s).
-      #
-      # Example:
-      #
-      #   should_not_assign_to :user, :posts
-      # 
-      def should_not_assign_to(*names)
-        names.each do |name|
-          it "should not assign to @#{name}" do
-            assigns(name.to_sym).should be_nil
-          end
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      # Macro that creates a test asserting that filter_parameter_logging
-      # is set for the specified keys
-      #
-      # Example:
-      #
-      #   should_filter_params :password, :ssn
-      # 
-      def filter_params(*keys)
-        simple_matcher "filter #{keys.to_sentence}" do
-          ret = true
-          keys.each do |key|
-            if controller.respond_to?(:filter_parameters)
-              filtered = controller.send(:filter_parameters, {key.to_s => key.to_s})
-              unless filtered[key.to_s] == '[FILTERED]'
-                ret = false
-                break  
-              end
-            else
-              ret = false
-              break
-            end
-          end
-          ret
-        end
-      end
-    end
-
-    module Shoulda
-      # Macro that creates a test asserting that filter_parameter_logging
-      # is set for the specified keys
-      #
-      # Example:
-      #
-      #   should_filter_params :password, :ssn
-      # 
-      def should_filter_params(*keys)
-        keys.each do |key|
-          it "should filter #{key}" do
-            controller.should respond_to(:filter_parameters)
-            filtered = controller.send(:filter_parameters, {key.to_s => key.to_s})
-            filtered[key.to_s].should == '[FILTERED]'
-          end
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,24 +0,0 @@
-module Remarkable
-  module Syntax
-    
-    module Shoulda
-      # Macro that creates a test asserting that the controller returned a redirect to the given path.
-      # The given string is evaled to produce the resulting redirect path.  All of the instance variables
-      # set by the controller are available to the evaled string.
-      # Example:
-      #
-      #   should_redirect_to '"/"'
-      #   should_redirect_to "user_url(@user)"
-      #   should_redirect_to "users_url"
-      # 
-      def should_redirect_to(url)
-        it "should redirect to #{url.inspect}" do
-          instantiate_variables_from_assigns do
-            response.should redirect_to(eval(url, self.send(:binding), __FILE__, __LINE__))
-          end
-        end
-      end
-    end
-  
-  end
-end

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

@@ -1,23 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      # Macro that creates a test asserting that the rendered view contains a <form> element.
-      def render_a_form
-        simple_matcher "should display a form" do |controller|
-          controller.response.should have_tag("form")
-        end
-      end
-    end
-
-    module Shoulda
-      # Macro that creates a test asserting that the rendered view contains a <form> element.
-      def should_render_a_form
-        it "should display a form" do
-          response.should have_tag("form")
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,18 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module Shoulda
-      # Macro that creates a test asserting that the controller rendered the given template.
-      # Example:
-      #
-      #   should_render_template :new
-      # 
-      def should_render_template(template)
-        it "should render template #{template.inspect}" do
-          response.should render_template(template.to_s)
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,61 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      # Macro that creates a test asserting that the controller rendered with the given layout.
-      # Example:
-      #
-      #   it { should render_with_layout('special') }
-      #   it { should render_with_layout(:special) }
-      # 
-      def render_with_layout(expected_layout = 'application')
-        if expected_layout
-          simple_matcher "render with #{expected_layout.inspect} layout" do |controller|
-            response_layout = response.layout.blank? ? "" : response.layout.split('/').last
-            response_layout.should == expected_layout.to_s
-          end
-        else
-          simple_matcher "render without layout" do
-            response.layout.should be_nil
-          end
-        end
-      end
-
-      # Macro that creates a test asserting that the controller rendered without a layout.
-      # Same as @it { should render_with_layout(false) }@
-      def render_without_layout
-        simple_matcher "render without layout" do |controller|
-          controller.should render_with_layout(nil)
-        end
-      end
-    end
-
-    module Shoulda
-      # Macro that creates a test asserting that the controller rendered with the given layout.
-      # Example:
-      #
-      #   should_render_with_layout 'special'
-      #   should_render_with_layout :special
-      # 
-      def should_render_with_layout(expected_layout = 'application')
-        if expected_layout
-          it "should render with #{expected_layout.inspect} layout" do
-            response_layout = response.layout.blank? ? "" : response.layout.split('/').last
-            response_layout.should == expected_layout.to_s
-          end
-        else
-          it "should render without layout" do
-            response.layout.should be_nil
-          end
-        end
-      end
-
-      # Macro that creates a test asserting that the controller rendered without a layout.
-      # Same as @should_render_with_layout false@
-      def should_render_without_layout
-        should_render_with_layout nil
-      end
-    end
-
-  end
-end

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

@@ -1,86 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class RespondWith
-        include Remarkable::Private
-
-        def initialize(response, type)
-          @response = response
-          @type = type
-        end
-
-        def matches?(controller)
-          @controller = controller
-
-          begin
-            if [ :success, :missing, :redirect, :error ].include?(@type) && @response.send("#{@type}?")
-            elsif @type.is_a?(Fixnum) && @response.response_code == @type
-            elsif @type.is_a?(Symbol) && @response.response_code == ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[@type]
-            else
-              if @response.error?
-                exception = @response.template.instance_variable_get(:@exception)
-                exception_message = exception && exception.message
-                fail "Expected response to be a #{@type}, but was #{@response.response_code}\n#{exception_message.to_s}"
-              else
-                fail "Expected response to be a #{@type}, but was #{@response.response_code}"
-              end
-            end
-
-            true
-          rescue Exception => e
-            false
-          end
-        end
-
-        def description
-          "respond with #{@type}"
-        end
-
-        def failure_message
-          @failure_message || "expected respond with #{@type}, but it didn't"
-        end
-
-        def negative_failure_message
-          "expected not respond with #{@type}, but it did"
-        end
-      end
-
-      # Macro that creates a test asserting that the controller responded with a 'response' status code.
-      # Example:
-      #
-      #   it { should respond_with(:success) }
-      #
-      def respond_with(type)
-        Remarkable::Syntax::RSpec::RespondWith.new(response, type)
-      end
-    end
-
-    module Shoulda
-      # Macro that creates a test asserting that the controller responded with a 'response' status code.
-      # Example:
-      #
-      #   should_respond_with :success
-      # 
-      def should_respond_with(type)
-        it "should respond with #{type}" do
-          clean_backtrace do
-            if [ :success, :missing, :redirect, :error ].include?(type) && response.send("#{type}?")
-            elsif type.is_a?(Fixnum) && response.response_code == type
-            elsif type.is_a?(Symbol) && response.response_code == ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[type]
-            else
-              if response.error?
-                exception = response.template.instance_variable_get(:@exception)
-                exception_message = exception && exception.message
-                Spec::Expectations.fail_with "Expected response to be a #{type}, but was #{response.response_code}\n#{exception_message.to_s}"
-              else
-                Spec::Expectations.fail_with "Expected response to be a #{type}, but was #{response.response_code}"
-              end
-            end
-          end
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,45 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      # Macro that creates a test asserting that the response content type was 'content_type'.
-      # Example:
-      #
-      #   should_respond_with_content_type 'application/rss+xml'
-      #   should_respond_with_content_type :rss
-      #   should_respond_with_content_type /rss/
-      # 
-      def respond_with_content_type(content_type)
-        simple_matcher "respond with content type of #{content_type}" do
-          content_type = Mime::EXTENSION_LOOKUP[content_type.to_s].to_s if content_type.is_a? Symbol
-          if content_type.is_a? Regexp
-            response.content_type =~ content_type
-          else
-            response.content_type == content_type
-          end
-        end
-      end
-    end
-
-    module Shoulda
-      # Macro that creates a test asserting that the response content type was 'content_type'.
-      # Example:
-      #
-      #   should_respond_with_content_type 'application/rss+xml'
-      #   should_respond_with_content_type :rss
-      #   should_respond_with_content_type /rss/
-      # 
-      def should_respond_with_content_type(content_type)
-        it "should respond with content type of #{content_type}" do
-          content_type = Mime::EXTENSION_LOOKUP[content_type.to_s].to_s if content_type.is_a? Symbol
-          if content_type.is_a? Regexp
-            response.content_type.should match(content_type)
-          else
-            response.content_type.should == content_type
-          end
-        end
-      end
-    end
-    
-  end
-end

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

@@ -1,45 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      # Macro that creates a test asserting that a value returned from the session is correct.
-      # The given string is evaled to produce the resulting redirect path.  All of the instance variables
-      # set by the controller are available to the evaled string.
-      # Example:
-      #
-      #   should_return_from_session :user_id, '@user.id'
-      #   should_return_from_session :message, '"Free stuff"'
-      # 
-      def return_from_session(key, expected)
-        simple_matcher "return the correct value from the session for key #{key}" do
-          ret = true
-          instantiate_variables_from_assigns do
-            expected_value = eval(expected, self.send(:binding), __FILE__, __LINE__)
-            ret = (session[key] == expected_value)
-          end
-          ret
-        end
-      end
-    end
-
-    module Shoulda
-      # Macro that creates a test asserting that a value returned from the session is correct.
-      # The given string is evaled to produce the resulting redirect path.  All of the instance variables
-      # set by the controller are available to the evaled string.
-      # Example:
-      #
-      #   should_return_from_session :user_id, '@user.id'
-      #   should_return_from_session :message, '"Free stuff"'
-      # 
-      def should_return_from_session(key, expected)
-        it "should return the correct value from the session for key #{key}" do
-          instantiate_variables_from_assigns do
-            expected_value = eval(expected, self.send(:binding), __FILE__, __LINE__)
-            session[key].should == expected_value
-          end
-        end
-      end
-    end
-
-  end
-end