remarkable_activerecord 3.0.0

data/locale/en.yml

@@ -0,0 +1,253 @@
+en:
+  remarkable:
+    active_record:
+      allow_nil: "{{subject_name}} to {{not}}allow nil values for {{attribute}}"
+      allow_blank: "{{subject_name}} to {{not}}allow blank values for {{attribute}}"
+
+      allow_values_for:
+        description: "allow {{in}} as values for {{attributes}}"
+        expectations:
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+        optionals:
+          allow_nil:
+            positive: "allowing nil values"
+            negative: "not allowing nil values"
+          allow_blank:
+            positive: "allowing blank values"
+            negative: "not allowing blank values"
+
+      allow_mass_assignment_of:
+        description: "allow mass assignment of {{attributes}}"
+        expectations:
+          is_protected: "{{subject_name}} to allow mass assignment of {{attribute}} ({{subject_name}} is protecting {{attribute}})"
+          is_accessible: "{{subject_name}} to allow mass assignment of {{attribute}} ({{subject_name}} has not made {{attribute}} accessible)"
+
+      association:
+        belongs_to: belong to
+        has_many: have many
+        has_and_belongs_to_many: have and belong to many
+        has_one: have one
+        description: "{{macro}} {{associations}}"
+        expectations:
+          association_exists: "{{subject_name}} records {{macro}} {{association}}, got no association"
+          macro_matches: "{{subject_name}} records {{macro}} {{association}}, got {{subject_name}} records {{actual_macro}} {{association}}"
+          through_exists: "{{subject_name}} records {{macro}} {{association}} through {{through}}, through association does not exist"
+          join_table_exists: "join table {{actual_join_table}} to exist, but does not"
+          foreign_key_exists: "foreign key {{actual_foreign_key}} to exist on {{foreign_key_table}}, but does not"
+          polymorphic_exists: "{{subject_table}} to have {{polymorphic_column}} as column, but does not"
+          counter_cache_exists: "{{reflection_table}} to have {{counter_cache_column}} as column, but does not"
+          through_matches: "{{association}} association through {{through}}, got {{actual_through}}"
+          class_name_matches: "{{association}} association with class name {{class_name}}, got {{actual_class_name}}"
+          foreign_key_matches: "{{association}} association with foreign key {{foreign_key}}, got {{actual_foreign_key}}"
+          dependent_matches: "{{association}} association with dependent {{dependent}}, got {{actual_dependent}}"
+          join_table_matches: "{{association}} association with join table {{join_table}}, got {{actual_join_table}}"
+          uniq_matches: "{{association}} association with uniq equals to {{uniq}}, got {{actual_uniq}}"
+          readonly_matches: "{{association}} association with readonly equals to {{readonly}}, got {{actual_readonly}}"
+          validate_matches: "{{association}} association with validate equals to {{validate}}, got {{actual_validate}}"
+          autosave_matches: "{{association}} association with autosave equals to {{autosave}}, got {{actual_autosave}}"
+          polymorphic_matches: "{{association}} association with polymorphic equals to {{polymorphic}}, got {{actual_polymorphic}}"
+          as_matches: "{{association}} association with polymorphic interface {{as}}, got {{actual_as}}"
+          counter_cache_matches: "{{association}} association with counter cache {{counter_cache}}, got {{actual_counter_cache}}"
+        optionals:
+          through:
+            positive: "through {{value}}"
+          class_name:
+            positive: "with class name {{inspect}}"
+          foreign_key:
+            positive: "with foreign key {{inspect}}"
+          dependent:
+            positive: "with dependent {{inspect}}"
+          join_table:
+            positive: "with join table {{inspect}}"
+          uniq:
+            positive: "with unique records"
+            negative: "without unique records"
+          readonly:
+            positive: "with readonly records"
+            negative: "without readonly records"
+          validate:
+            positive: "validating associated records"
+            negative: "not validating associated records"
+          autosave:
+            positive: "autosaving associated records"
+            negative: "not autosaving associated records"
+          polymorphic:
+            positive: "through a polymorphic interface"
+          as:
+            positive: "through the polymorphic interface {{inspect}}"
+          counter_cache:
+            positive: "with counter cache {{inspect}}"
+            negative: "without counter cache"
+
+      have_column:
+        description: "have column(s) named {{columns}}"
+        expectations:
+          column_exists: "{{subject_name}} to have column named {{column}}"
+          options_match: "{{subject_name}} to have column {{column}} with options {{options}}, got {{actual}}"
+        optionals:
+          type:
+            positive: "with type {{inspect}}"
+          null:
+            positive: "allowing null values"
+            negative: "not allowing null values"
+          default:
+            positive: "with default {{inspect}}"
+            negative: "with default {{inspect}}"
+          limit:
+            positive: "with limit {{inspect}}"
+
+      have_index:
+        description: "have index for column(s) {{columns}}"
+        expectations:
+          index_exists: "index {{column}} to exist on table {{table_name}}"
+          is_unique: "index on {{column}} with unique equals to {{unique}}, got {{actual}}"
+        optionals:
+          unique:
+            positive: "with unique values"
+            negative: "with non unique values"
+
+      have_readonly_attributes:
+        description: "make {{attributes}} read-only"
+        expectations:
+          is_readonly: "{{subject_name}} to make {{attribute}} read-only, got {{actual}}"
+
+      have_scope:
+        description: "have to scope itself to {{options}} when {{scope_name}} is called"
+        expectations:
+          is_scope: "{{scope_name}} when called on {{subject_name}} return a ActiveRecord::NamedScope::Scope object"
+          options_match: "{{scope_name}} when called on {{subject_name}} scope to {{options}}, got {{actual}}"
+        optionals:
+          with:
+            positive: "with {{inspect}} as argument"
+
+      validate_acceptance_of:
+        description: "require {{attributes}} to be accepted"
+        expectations:
+          requires_acceptance: "{{subject_name}} to be invalid if {{attribute}} is not accepted"
+          accept_is_valid: "{{subject_name}} to be valid when {{attribute}} is accepted with value {{accept}}"
+        optionals:
+          accept:
+            positive: "with value {{inspect}}"
+          allow_nil:
+            positive: "allowing nil values"
+            negative: "not allowing nil values"
+
+      validate_associated:
+        description: "require associated {{associations}} to be valid"
+        expectations:
+          is_valid: "{{subject_name}} to be invalid when {{association}} is invalid"
+
+      validate_confirmation_of:
+        description: "require {{attributes}} to be confirmed"
+        expectations:
+          responds_to_confirmation: "{{subject_name}} instance responds to {{attribute}}_confirmation"
+          confirms: "{{subject_name}} to be valid only when {{attribute}} is confirmed"
+
+      validate_exclusion_of:
+        description: "ensure exclusion of {{attributes}} in {{in}}"
+        expectations:
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+          is_invalid: "{{subject_name}} to be invalid when {{attribute}} is set to {{value}}"
+        optionals:
+          allow_nil:
+            positive: "allowing nil values"
+            negative: "not allowing nil values"
+          allow_blank:
+            positive: "allowing blank values"
+            negative: "not allowing blank values"
+
+      validate_inclusion_of:
+        description: "ensure inclusion of {{attributes}} in {{in}}"
+        expectations:
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+          is_invalid: "{{subject_name}} to be invalid when {{attribute}} is set to {{value}}"
+        optionals:
+          allow_nil:
+            positive: "allowing nil values"
+            negative: "not allowing nil values"
+          allow_blank:
+            positive: "allowing blank values"
+            negative: "not allowing blank values"
+
+      validate_length_of:
+        description: "ensure length of {{attributes}}"
+        expectations:
+          less_than_min_length: "{{subject_name}} to be invalid when {{attribute}} length is less than {{minimum}} characters"
+          exactly_min_length: "{{subject_name}} to be valid when {{attribute}} length is {{minimum}} characters"
+          more_than_max_length: "{{subject_name}} to be invalid when {{attribute}} length is more than {{maximum}} characters"
+          exactly_max_length: "{{subject_name}} to be valid when {{attribute}} length is {{maximum}} characters"
+        optionals:
+          within:
+            positive: "is within {{inspect}} characters"
+          maximum:
+            positive: "is maximum {{inspect}} characters"
+          minimum:
+            positive: "is minimum {{inspect}} characters"
+          is:
+            positive: "is equal to {{inspect}} characters"
+          allow_nil:
+            positive: "allowing nil values"
+            negative: "not allowing nil values"
+          allow_blank:
+            positive: "allowing blank values"
+            negative: "not allowing blank values"
+
+      validate_numericality_of:
+        description: "ensure numericality of {{attributes}}"
+        expectations:
+          only_numeric_values: "{{subject_name}} to allow only numeric values for {{attribute}}"
+          only_integer: "{{subject_name}} to {{not}}allow only integer values for {{attribute}}"
+          only_even: "{{subject_name}} to allow only even values for {{attribute}}"
+          only_odd: "{{subject_name}} to allow only odd values for {{attribute}}"
+          equals_to: "{{subject_name}} to be valid only when {{attribute}} is equal to {{count}}"
+          more_than_maximum: "{{subject_name}} to be invalid when {{attribute}} is greater than {{count}}"
+          less_than_minimum: "{{subject_name}} to be invalid when {{attribute}} is less than {{count}}"
+        optionals:
+          only_integer:
+            positive: "allowing only integer values"
+          odd:
+            positive: "allowing only odd values"
+          even:
+            positive: "allowing only even values"
+          equal_to:
+            positive: "is equal to {{inspect}}"
+          less_than:
+            positive: "is less than {{inspect}}"
+          greater_than:
+            positive: "is greater than {{inspect}}"
+          less_than_or_equal_to:
+            positive: "is less than or equal to {{inspect}}"
+          greater_than_or_equal_to:
+            positive: "is greater than or equal to {{inspect}}"
+          allow_nil:
+            positive: "allowing nil values"
+            negative: "not allowing nil values"
+          allow_blank:
+            positive: "allowing blank values"
+            negative: "not allowing blank values"
+
+      validate_presence_of:
+        description: "require {{attributes}} to be set"
+        expectations:
+          allow_nil: "{{subject_name}} to require {{attribute}} to be set"
+
+      validate_uniqueness_of:
+        description: "require unique values for {{attributes}}"
+        expectations:
+          responds_to_scope: "{{subject_name}} instance responds to {{method}}"
+          is_unique: "{{subject_name}} to require unique values for {{attribute}}"
+          case_sensitive: "{{subject_name}} to {{not}}be case sensitive on {{attribute}} validation"
+          valid_with_new_scope: "{{subject_name}} to be valid when {{attribute}} scope ({{method}}) change"
+        optionals:
+          scope:
+            positive: "scoped to {{inspect}}"
+          case_sensitive:
+            positive: "case sensitive"
+            negative: "case insensitive"
+          allow_nil:
+            positive: "allowing nil values"
+            negative: "not allowing nil values"
+          allow_blank:
+            positive: "allowing blank values"
+            negative: "not allowing blank values"
+

data/spec/allow_mass_assignment_of_matcher_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'allow_mass_assignment_of' do
+  include ModelBuilder
+
+  def define_and_validate(options={})
+    @model = define_model :product, :title => :string, :category => :string do
+      attr_protected  :title, :category     if options[:protected]
+
+      attr_accessible :title, :category     if options[:accessible] == true
+      attr_accessible *options[:accessible] if options[:accessible].is_a?(Array)
+    end
+
+    allow_mass_assignment_of(:title, :category)
+  end
+
+  describe 'messages' do
+
+    it 'should contain a description' do
+      @matcher = allow_mass_assignment_of(:title, :category)
+      @matcher.description.should == 'allow mass assignment of title and category'
+    end
+
+    it 'should set is_protected? message' do
+      @matcher = define_and_validate(:protected => true)
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow mass assignment of title (Product is protecting title)'
+    end
+
+    it 'should set is_accessible? message' do
+      @matcher = define_and_validate(:accessible => [:another])
+      @matcher.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow mass assignment of title (Product has not made title accessible)'
+    end
+
+  end
+
+  describe 'matchers' do
+    it { should define_and_validate }
+    it { should define_and_validate(:accessible => true) }
+
+    it { should_not define_and_validate(:protected => true) }
+    it { should_not define_and_validate(:accessible => [:another]) }
+  end
+
+  describe 'macros' do
+    before(:each){ define_and_validate(:accessible => true) }
+
+    should_allow_mass_assignment_of :title
+    should_allow_mass_assignment_of :category
+    should_allow_mass_assignment_of :title, :category
+
+    should_not_allow_mass_assignment_of :another
+    should_not_allow_mass_assignment_of :title, :another
+  end
+end
+

data/spec/allow_values_for_matcher_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'allow_values_for' do
+  include ModelBuilder
+
+  # Defines a model, create a validation and returns a raw matcher
+  def define_and_validate(options={})
+    @model = define_model :product, :title => :string, :category => :string do
+      validates_format_of :title, options
+    end
+
+    allow_values_for(:title)
+  end
+
+  describe 'messages' do
+    before(:each){ @matcher = define_and_validate(:with => /X|Y|Z/) }
+
+    it 'should contain a description' do
+      @matcher = allow_values_for(:title, "X", "Y", "Z")
+      @matcher.description.should == 'allow "X", "Y", and "Z" as values for title'
+    end
+
+    it 'should set is_valid? message' do
+      @matcher.in("A").matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to be valid when title is set to "A"'
+    end
+
+    it 'should set allow_nil? message' do
+      @matcher.allow_nil.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow nil values for title'
+    end
+
+    it 'should set allow_blank? message' do
+      @matcher.allow_blank.matches?(@model)
+      @matcher.failure_message.should == 'Expected Product to allow blank values for title'
+    end
+  end
+
+  describe 'matchers' do
+    it { should define_and_validate(:with => /X|Y|Z/).in('X', 'Y', 'Z') }
+    it { should_not define_and_validate(:with => /X|Y|Z/).in('A') }
+
+    it { should define_and_validate(:with => /X|Y|Z/, :message => 'valid').in('X', 'Y', 'Z').message('valid') }
+
+    create_optional_boolean_specs(:allow_nil, self, :with => /X|Y|Z/)
+    create_optional_boolean_specs(:allow_blank, self, :with => /X|Y|Z/)
+  end
+
+  describe 'macros' do
+    before(:each){ define_and_validate(:with => /X|Y|Z/) }
+
+    should_allow_values_for :title, 'X'
+    should_not_allow_values_for :title, 'A'
+  end
+end
+