carlosbrando-remarkable 0.0.99 → 2.2.1

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

@@ -1,148 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class HaveNamedScope
-        def initialize(scope_call, *args)
-          @scope_opts = args.extract_options!
-          @scope_call = scope_call.to_s
-          @args       = args
-        end
-
-        def matches?(klass)
-          @klass = klass
-
-          begin
-            scope = eval("#{klass}.#{@scope_call}")
-
-            unless scope.class == ::ActiveRecord::NamedScope::Scope
-              fail "#{@scope_call} didn't return a scope object"
-            end
-
-            unless @scope_opts.empty? 
-              unless scope.proxy_options == @scope_opts
-                fail "#{klass.name} didn't scope itself to #{@scope_opts.inspect}"
-              end
-            end
-
-            true
-          rescue Exception => e
-            false
-          end
-        end
-
-        def description
-          "have to scope itself to #{@scope_opts.inspect} when #{@scope_call} is called"
-        end
-
-        def failure_message
-          @failure_message || "expected that #{klass.name} has a method named #{@scope_call} that returns a NamedScope object with the proxy options set to the options you supply, but it didn't"
-        end
-
-        def negative_failure_message
-          "expected that #{klass.name} hasn't a method named #{@scope_call} that returns a NamedScope object with the proxy options set to the options you supply, but it did"
-        end
-      end
-
-      # Ensures that the model has a method named scope_name that returns a NamedScope object with the
-      # proxy options set to the options you supply.  scope_name can be either a symbol, or a method
-      # call which will be evaled against the model.  The eval'd method call has access to all the same
-      # instance variables that a should statement would.
-      #
-      # Options: Any of the options that the named scope would pass on to find.
-      #
-      # Example:
-      # 
-      #   it { User.should have_named_scope(:visible, :conditions => {:visible => true}) }
-      #
-      # Passes for
-      #
-      #   named_scope :visible, :conditions => {:visible => true}
-      #
-      # Or for
-      #
-      #   def self.visible
-      #     scoped(:conditions => {:visible => true})
-      #   end
-      #
-      # You can test lambdas or methods that return ActiveRecord#scoped calls:
-      #
-      #   it { User.should have_named_scope('recent(5)', :limit => 5) }
-      #   it { User.should have_named_scope('recent(1)', :limit => 1) }
-      #
-      # Passes for
-      #   named_scope :recent, lambda {|c| {:limit => c}}
-      #
-      # Or for
-      #
-      #   def self.recent(c)
-      #     scoped(:limit => c)
-      #   end
-      #
-      def have_named_scope(scope_call, *args)
-        Remarkable::Syntax::RSpec::HaveNamedScope.new(scope_call, *args)
-      end
-    end
-
-    module Shoulda
-      # Ensures that the model has a method named scope_name that returns a NamedScope object with the
-      # proxy options set to the options you supply.  scope_name can be either a symbol, or a method
-      # call which will be evaled against the model.  The eval'd method call has access to all the same
-      # instance variables that a should statement would.
-      #
-      # Options: Any of the options that the named scope would pass on to find.
-      #
-      # Example:
-      #
-      #   should_have_named_scope :visible, :conditions => {:visible => true}
-      #
-      # Passes for
-      #
-      #   named_scope :visible, :conditions => {:visible => true}
-      #
-      # Or for
-      #
-      #   def self.visible
-      #     scoped(:conditions => {:visible => true})
-      #   end
-      #
-      # You can test lambdas or methods that return ActiveRecord#scoped calls:
-      #
-      #   should_have_named_scope 'recent(5)', :limit => 5
-      #   should_have_named_scope 'recent(1)', :limit => 1
-      #
-      # Passes for
-      #   named_scope :recent, lambda {|c| {:limit => c}}
-      #
-      # Or for
-      #
-      #   def self.recent(c)
-      #     scoped(:limit => c)
-      #   end
-      #
-      def should_have_named_scope(scope_call, *args)
-        klass = model_class
-        scope_opts = args.extract_options!
-        scope_call = scope_call.to_s
-
-        describe scope_call do
-          before(:each) do
-            @scope = eval("#{klass}.#{scope_call}")
-          end
-          
-          it "should return a scope object" do
-            @scope.class.should == ::ActiveRecord::NamedScope::Scope
-          end
-
-          unless scope_opts.empty?
-            it "should scope itself to #{scope_opts.inspect}" do
-              @scope.proxy_options.should == scope_opts
-            end
-          end
-        end
-      end
-      
-    end
-
-  end
-end

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

@@ -1,81 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class HaveReadonlyAttributes
-        include Remarkable::Private
-        
-        def initialize(*attributes)
-          get_options!(attributes)
-          @attributes = attributes
-        end
-
-        def matches?(klass)
-          @klass = klass
-
-          begin
-            @attributes.each do |attribute|
-              attribute = attribute.to_sym
-              readonly = klass.readonly_attributes || []
-
-              unless readonly.include?(attribute.to_s)
-                fail readonly.empty? ?
-                "#{klass} attribute #{attribute} is not read-only" :
-                "#{klass} is making #{readonly.to_a.to_sentence} read-only, but not #{attribute}"
-              end
-            end
-
-            true
-          rescue Exception => e
-            false
-          end
-        end
-
-        def description
-          "make #{@attributes.to_sentence} read-only"
-        end
-
-        def failure_message
-          @failure_message || "expected that #{@attributes.to_sentence} cannot be changed once the record has been created, but it did"
-        end
-
-        def negative_failure_message
-          "expected that #{@attributes.to_sentence} cann be changed once the record has been created, but it didn't"
-        end
-      end
-
-      # Ensures that the attribute cannot be changed once the record has been created.
-      #
-      #   it { User.should have_readonly_attributes(:password, :admin_flag) }
-      #
-      def have_readonly_attributes(*attributes)
-        Remarkable::Syntax::RSpec::HaveReadonlyAttributes.new(*attributes)
-      end
-    end
-
-    module Shoulda
-      # Ensures that the attribute cannot be changed once the record has been created.
-      #
-      #   should_have_readonly_attributes :password, :admin_flag
-      #
-      def should_have_readonly_attributes(*attributes)
-        get_options!(attributes)
-        klass = model_class
-
-        attributes.each do |attribute|
-          attribute = attribute.to_sym
-          it "should make #{attribute} read-only" do
-            readonly = klass.readonly_attributes || []
-
-            unless readonly.include?(attribute.to_s)
-              fail_with(readonly.empty? ?
-                        "#{klass} attribute #{attribute} is not read-only" :
-                        "#{klass} is making #{readonly.to_a.to_sentence} read-only, but not #{attribute}.")
-            end
-          end
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,89 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class OnlyAllowNumericValuesFor
-        include Remarkable::Private
-        
-        def initialize(*attributes)
-          @message = get_options!(attributes, :message)
-          @message ||= default_error_message(:not_a_number)
-
-          @attributes = attributes
-        end
-
-        def matches?(klass)
-          @klass = klass
-
-          begin
-            @attributes.each do |attribute|
-              attribute = attribute.to_sym
-              return false unless assert_bad_value(klass, attribute, "abcd", @message)
-            end
-
-            true
-          rescue Exception => e
-            false
-          end
-        end
-
-        def description
-          "only allow numeric values for #{@attributes.to_sentence}"
-        end
-
-        def failure_message
-          "expected only numeric values for #{@attributes.to_sentence}, but it didn't"
-        end
-
-        def negative_failure_message
-          "expected not only numeric values for #{@attributes.to_sentence}, but it did"
-        end
-      end
-
-      # Ensure that the attribute is numeric
-      #
-      # If an instance variable has been created in the setup named after the
-      # model being tested, then this method will use that.  Otherwise, it will
-      # create a new instance to test against.
-      #
-      # 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.not_a_number')</tt>
-      #
-      # Example:
-      #   it { User.should only_allow_numeric_values_for(:age) }
-      #
-      def only_allow_numeric_values_for(*attributes)
-        Remarkable::Syntax::RSpec::OnlyAllowNumericValuesFor.new(*attributes)
-      end
-    end
-
-    module Shoulda
-      # Ensure that the attribute is numeric
-      #
-      # If an instance variable has been created in the setup named after the
-      # model being tested, then this method will use that.  Otherwise, it will
-      # create a new instance to test against.
-      #
-      # 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.not_a_number')</tt>
-      #
-      # Example:
-      #   should_only_allow_numeric_values_for :age
-      #
-      def should_only_allow_numeric_values_for(*attributes)
-        message = get_options!(attributes, :message)
-        message ||= default_error_message(:not_a_number)
-        klass = model_class
-        attributes.each do |attribute|
-          attribute = attribute.to_sym
-          it "should only allow numeric values for #{attribute}" do
-            assert_bad_value(klass, attribute, "abcd", message).should be_true
-          end
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,89 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class ProtectAttributes
-        include Remarkable::Private
-        
-        def initialize(*attributes)
-          get_options!(attributes)
-          @attributes = attributes
-        end
-
-        def matches?(klass)
-          @klass = klass
-
-          begin
-            @attributes.each do |attribute|
-              attribute = attribute.to_sym
-              protected = klass.protected_attributes || []
-              accessible = klass.accessible_attributes || []
-
-              unless protected.include?(attribute.to_s) || (!accessible.empty? && !accessible.include?(attribute.to_s))
-                message = if accessible.empty?
-                  "#{klass} is protecting #{protected.to_a.to_sentence}, but not #{attribute}."
-                else
-                  "#{klass} has made #{attribute} accessible"
-                end
-                fail(message)
-              end
-            end
-
-            true
-          rescue Exception => e
-            false
-          end
-        end
-
-        def description
-          "protect #{@attributes.to_sentence} from mass updates"
-        end
-
-        def failure_message
-          "expected that #{@attributes.to_sentence} cannot be set on mass update, but it did"
-        end
-
-        def negative_failure_message
-          "expected that #{@attributes.to_sentence} can be set on mass update, but it didn't"
-        end
-      end
-
-      # Ensures that the attribute cannot be set on mass update.
-      #
-      #   it { User.should protect_attributes(:password, :admin_flag) }
-      #
-      def protect_attributes(*attributes)
-        Remarkable::Syntax::RSpec::ProtectAttributes.new(*attributes)
-      end
-    end
-
-    module Shoulda
-      # Ensures that the attribute cannot be set on mass update.
-      #
-      #   should_protect_attributes :password, :admin_flag
-      #
-      def should_protect_attributes(*attributes)
-        get_options!(attributes)
-        klass = model_class
-
-        attributes.each do |attribute|
-          attribute = attribute.to_sym
-          it "should protect #{attribute} from mass updates" do
-            protected = klass.protected_attributes || []
-            accessible = klass.accessible_attributes || []
-
-            unless protected.include?(attribute.to_s) || (!accessible.empty? && !accessible.include?(attribute.to_s))
-              message = if accessible.empty?
-                "#{klass} is protecting #{protected.to_a.to_sentence}, but not #{attribute}."
-              else
-                "#{klass} has made #{attribute} accessible"
-              end
-              fail_with(message)
-            end
-          end
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,94 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class RequireAcceptanceOf
-        include Remarkable::Private
-        
-        def initialize(*attributes)
-          @message = get_options!(attributes, :message)
-          @message ||= default_error_message(:accepted)
-
-          @attributes = attributes
-        end
-
-        def matches?(klass)
-          @klass = klass
-
-          begin
-            @attributes.each do |attribute|
-              return false unless assert_bad_value(klass, attribute, false, @message)
-            end
-
-            true
-          rescue Exception => e
-            false
-          end
-        end
-
-        def description
-          "require #{@attributes.to_sentence} to be accepted"
-        end
-
-        def failure_message
-          message = "expected that the #{@klass.name} cannot be saved if #{@attributes.to_sentence} "
-          message += @attributes.size > 1 ? "are" : "is"
-          message += " not accepted, but it did"
-          message
-        end
-
-        def negative_failure_message
-          message = "expected that the #{@klass.name} can be saved if #{@attributes.to_sentence} "
-          message += @attributes.size > 1 ? "are" : "is"
-          message += " not accepted, but it didn't"
-          message
-        end
-      end
-
-      # Ensures that the model cannot be saved if one of the attributes listed is not accepted.
-      #
-      # If an instance variable has been created in the setup named after the
-      # model being tested, then this method will use that.  Otherwise, it will
-      # create a new instance to test against.
-      #
-      # 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.accepted')</tt>
-      #
-      # Example:
-      #   it { User.should require_acceptance_of(:eula) }
-      #
-      def require_acceptance_of(*attributes)
-        Remarkable::Syntax::RSpec::RequireAcceptanceOf.new(*attributes)
-      end
-    end
-
-    module Shoulda
-      # Ensures that the model cannot be saved if one of the attributes listed is not accepted.
-      #
-      # If an instance variable has been created in the setup named after the
-      # model being tested, then this method will use that.  Otherwise, it will
-      # create a new instance to test against.
-      #
-      # 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.accepted')</tt>
-      #
-      # Example:
-      #   should_require_acceptance_of :eula
-      #
-      def should_require_acceptance_of(*attributes)
-        message = get_options!(attributes, :message)
-        message ||= default_error_message(:accepted)
-        klass = model_class
-
-        attributes.each do |attribute|
-          it "should require #{attribute} to be accepted" do
-            assert_bad_value(klass, attribute, false, message).should be_true
-          end
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,94 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class RequireAttributes
-        include Remarkable::Private
-        
-        def initialize(*attributes)
-          @message = get_options!(attributes, :message)
-          @message ||= default_error_message(:blank)
-
-          @attributes = attributes
-        end
-
-        def matches?(klass)
-          @klass = klass
-
-          begin
-            @attributes.each do |attribute|
-              return false unless assert_bad_value(klass, attribute, nil, @message)
-            end
-
-            true
-          rescue Exception => e
-            false
-          end
-        end
-
-        def description
-          "require #{@attributes.to_sentence} to be set"
-        end
-
-        def failure_message
-          message = "expected that the #{@klass.name} cannot be saved if #{@attributes.to_sentence} "
-          message += @attributes.size > 1 ? "are" : "is"
-          message += " not present, but it did"
-          message
-        end
-
-        def negative_failure_message
-          message = "expected that the #{@klass.name} can be saved if #{@attributes.to_sentence} "
-          message += @attributes.size > 1 ? "are" : "is"
-          message += " not present, but it didn't"
-          message
-        end
-      end
-
-      # Ensures that the model cannot be saved if one of the attributes listed is not present.
-      #
-      # If an instance variable has been created in the setup named after the
-      # model being tested, then this method will use that.  Otherwise, it will
-      # create a new instance to test against.
-      #
-      # 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.blank')</tt>
-      #
-      # Example:
-      #   it { User.should require_attributes(:name, :phone_number) }
-      #
-      def require_attributes(*attributes)
-        Remarkable::Syntax::RSpec::RequireAttributes.new(*attributes)
-      end
-    end
-
-    module Shoulda
-      # Ensures that the model cannot be saved if one of the attributes listed is not present.
-      #
-      # If an instance variable has been created in the setup named after the
-      # model being tested, then this method will use that.  Otherwise, it will
-      # create a new instance to test against.
-      #
-      # 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.blank')</tt>
-      #
-      # Example:
-      #   should_require_attributes :name, :phone_number
-      #
-      def should_require_attributes(*attributes)
-        message = get_options!(attributes, :message)
-        message ||= default_error_message(:blank)
-        klass = model_class
-
-        attributes.each do |attribute|
-          it "should require #{attribute} to be set" do
-            assert_bad_value(klass, attribute, nil, message).should be_true
-          end
-        end
-      end
-    end
-
-  end
-end