benhutton-remarkable_activerecord 4.0.0.alpha6

data/locale/en.yml

@@ -0,0 +1,264 @@
+en:
+  remarkable:
+    active_record:
+      describe:
+        each: "%{key} is %{value}"
+        prepend: "when "
+        connector: " and "
+      expectations:
+        allow_nil: "%{subject_name} to %{not}allow nil values for %{attribute}"
+        allow_blank: "%{subject_name} to %{not}allow blank values for %{attribute}"
+      optionals:
+        allow_nil:
+          positive: "allowing nil values"
+          negative: "not allowing nil values"
+        allow_blank:
+          positive: "allowing blank values"
+          negative: "not allowing blank values"
+
+      accept_nested_attributes_for:
+        description: "accept nested attributes for %{associations}"
+        expectations:
+          association_exists: "%{subject_name} to have association %{association}, but does not"
+          is_autosave: "%{subject_name} to have association %{association} with autosave true, got false"
+          responds_to_attributes: "%{subject_name} to respond to :%{association}_attributes=, but does not"
+          allows_destroy: "%{subject_name} with allow destroy equals to %{allow_destroy}, got %{actual}"
+          accepts: "%{subject_name} to accept attributes %{attributes} for %{association}, but does not"
+          rejects: "%{subject_name} to reject attributes %{attributes} for %{association}, but does not"
+        optionals:
+          allow_destroy:
+            positive: "allowing destroy"
+            negative: "not allowing destroy"
+          accept:
+            positive: "accepting %{sentence}"
+          reject:
+            positive: "rejecting %{sentence}"
+
+      allow_values_for:
+        description: "allow %{in} as values for %{attributes}"
+        expectations:
+          is_valid: "%{subject_name} to be valid when %{attribute} is set to %{value}"
+
+      allow_mass_assignment_of:
+        description: "allow mass assignment of %{attributes}"
+        expectations:
+          allows: "%{subject_name} to allow mass assignment (%{subject_name} is protecting %{protected_attributes})"
+          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)"
+        negative_expectations:
+          allows: "%{subject_name} to allow mass assignment (%{subject_name} made %{accessible_attributes} accessible)"
+          is_protected: "%{subject_name} to allow mass assignment of %{attribute} (%{subject_name} is not protecting %{attribute})"
+          is_accessible: "%{subject_name} to allow mass assignment of %{attribute} (%{subject_name} has 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}, but the association does not exist"
+          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"
+          source_exists: "%{subject_name} records %{macro} %{association} through %{through}, source association does not exist"
+          klass_exists: "%{subject_name} records %{macro} %{association}, but the association class does not exist"
+          join_table_exists: "join table %{join_table} to exist, but does not"
+          foreign_key_exists: "foreign key %{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"
+          options_match: "%{subject_name} records %{macro} %{association} with options %{options}, got %{actual}"
+        optionals:
+          through:
+            positive: "through %{value}"
+          source:
+            positive: "with source %{inspect}"
+          source_type:
+            positive: "with source type %{inspect}"
+          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"
+          as:
+            positive: "through the polymorphic interface %{inspect}"
+          counter_cache:
+            positive: "with counter cache %{inspect}"
+            negative: "without counter cache"
+          select:
+            positive: "selecting %{inspect}"
+          conditions:
+            positive: "with conditions %{inspect}"
+          include:
+            positive: "including %{inspect}"
+          group:
+            positive: "grouping by %{inspect}"
+          having:
+            positive: "having %{inspect}"
+          order:
+            positive: "with order %{inspect}"
+          limit:
+            positive: "with limit %{inspect}"
+          offset:
+            positive: "with offset %{inspect}"
+
+      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 value %{inspect}"
+            negative: "with default value %{inspect}"
+          limit:
+            positive: "with limit %{inspect}"
+
+      have_default_scope:
+        description: "have a default scope with %{options}"
+        expectations:
+          options_match: "default scope with %{options}, got %{actual}"
+
+      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"
+          table_name:
+            positive: "on table %{value}"
+
+      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 an instance of ActiveRecord::NamedScope::Scope"
+          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}"
+
+      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}"
+
+      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}"
+
+      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"
+          with_kind_of:
+            positive: "with kind of %{value}"
+
+      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}"
+
+      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 %{sentence}"
+          case_sensitive:
+            positive: "case sensitive"
+            negative: "case insensitive"
+

data/remarkable_activerecord.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{remarkable_activerecord}
+  s.version = "4.0.0.alpha5"
+
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ho-Sheng Hsiao", "Carlos Brando", "José Valim", "Diego Carrion"]
+  s.date = %q{2010-11-15}
+  s.description = %q{Remarkable ActiveRecord: collection of matchers and macros with I18n for ActiveRecord}
+  s.email = ["hosh@sparkfly.com", "eduardobrando@gmail.com", "jose.valim@gmail.com", "dc.rec1@gmail.com"]
+  s.extra_rdoc_files = [
+    "CHANGELOG",
+     "LICENSE",
+     "README"
+  ]
+  s.files = [
+    "CHANGELOG",
+     "LICENSE",
+     "README",
+     "benhutton-remarkable_activerecord.gemspec",
+     "lib/remarkable/active_record.rb",
+     "lib/remarkable/active_record/base.rb",
+     "lib/remarkable/active_record/matchers/accept_nested_attributes_for_matcher.rb",
+     "lib/remarkable/active_record/matchers/allow_mass_assignment_of_matcher.rb",
+     "lib/remarkable/active_record/matchers/association_matcher.rb",
+     "lib/remarkable/active_record/matchers/have_column_matcher.rb",
+     "lib/remarkable/active_record/matchers/have_default_scope_matcher.rb",
+     "lib/remarkable/active_record/matchers/have_index_matcher.rb",
+     "lib/remarkable/active_record/matchers/have_readonly_attributes_matcher.rb",
+     "lib/remarkable/active_record/matchers/have_scope_matcher.rb",
+     "lib/remarkable/active_record/matchers/validate_associated_matcher.rb",
+     "lib/remarkable/active_record/matchers/validate_uniqueness_of_matcher.rb",
+     "locale/en.yml",
+     "remarkable_activerecord.gemspec"
+  ]
+  s.homepage = %q{http://github.com/benhutton/remarkable}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{remarkable}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Remarkable ActiveRecord: collection of matchers and macros with I18n for ActiveRecord}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rspec>, [">= 2.0.0"])
+      s.add_runtime_dependency(%q<remarkable>, ["~> 4.0.0.alpha5"])
+      s.add_runtime_dependency(%q<remarkable_activemodel>, ["~> 4.0.0.alpha5"])
+    else
+      s.add_dependency(%q<rspec>, [">= 2.0.0"])
+      s.add_dependency(%q<remarkable>, ["~> 4.0.0.alpha5"])
+      s.add_dependency(%q<remarkable_activemodel>, ["~> 4.0.0.alpha5"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 2.0.0"])
+    s.add_dependency(%q<remarkable>, ["~> 4.0.0.alpha5"])
+    s.add_dependency(%q<remarkable_activemodel>, ["~> 4.0.0.alpha5"])
+  end
+end
+

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification 
+name: benhutton-remarkable_activerecord
+version: !ruby/object:Gem::Version 
+  prerelease: true
+  segments: 
+  - 4
+  - 0
+  - 0
+  - alpha6
+  version: 4.0.0.alpha6
+platform: ruby
+authors: 
+- Ho-Sheng Hsiao
+- Carlos Brando
+- "Jos\xC3\xA9 Valim"
+- Diego Carrion
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-15 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: remarkable
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 4
+        - 0
+        - 0
+        - alpha4
+        version: 4.0.0.alpha4
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: remarkable_activemodel
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 4
+        - 0
+        - 0
+        - alpha4
+        version: 4.0.0.alpha4
+  type: :runtime
+  version_requirements: *id003
+description: "Remarkable ActiveRecord: collection of matchers and macros with I18n for ActiveRecord"
+email: 
+- hosh@sparkfly.com
+- eduardobrando@gmail.com
+- jose.valim@gmail.com
+- dc.rec1@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG
+- LICENSE
+- README
+files: 
+- CHANGELOG
+- LICENSE
+- README
+- benhutton-remarkable_activerecord.gemspec
+- lib/remarkable/active_record.rb
+- lib/remarkable/active_record/base.rb
+- lib/remarkable/active_record/matchers/accept_nested_attributes_for_matcher.rb
+- lib/remarkable/active_record/matchers/allow_mass_assignment_of_matcher.rb
+- lib/remarkable/active_record/matchers/association_matcher.rb
+- lib/remarkable/active_record/matchers/have_column_matcher.rb
+- lib/remarkable/active_record/matchers/have_default_scope_matcher.rb
+- lib/remarkable/active_record/matchers/have_index_matcher.rb
+- lib/remarkable/active_record/matchers/have_readonly_attributes_matcher.rb
+- lib/remarkable/active_record/matchers/have_scope_matcher.rb
+- lib/remarkable/active_record/matchers/validate_associated_matcher.rb
+- lib/remarkable/active_record/matchers/validate_uniqueness_of_matcher.rb
+- locale/en.yml
+- remarkable_activerecord.gemspec
+has_rdoc: true
+homepage: http://github.com/benhutton/remarkable
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: remarkable
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: "Remarkable ActiveRecord: collection of matchers and macros with I18n for ActiveRecord"
+test_files: []
+